[]Struct lumol::sys::MoleculeIter

pub struct MoleculeIter<'a> { /* fields omitted */ }

An iterator over all the molecules in a Configuration

Trait Implementations

impl<'a> Send for MoleculeIter<'a>

impl<'a> DoubleEndedIterator for MoleculeIter<'a>

fn nth_back(&mut self, n: usize) -> Option<Self::Item>[src]

🔬 This is a nightly-only experimental API. (iter_nth_back)

Returns the nth element from the end of the iterator. Read more

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 
1.27.0
[src]

This is the reverse version of [try_fold()]: it takes elements starting from the back of the iterator. Read more

fn rfold<B, F>(self, accum: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 
1.27.0
[src]

An iterator method that reduces the iterator's elements to a single, final value, starting from the back. Read more

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool
1.27.0
[src]

Searches for an element of an iterator from the back that satisfies a predicate. Read more

impl<'a> Iterator for MoleculeIter<'a>

type Item = MoleculeRef<'a>

The type of the elements being iterated over.

fn last(self) -> Option<Self::Item>
1.0.0
[src]

Consumes the iterator, returning the last element. Read more

fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0
[src]

Returns the nth element of the iterator. Read more

fn step_by(self, step: usize) -> StepBy<Self>
1.28.0
[src]

Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator<Item = Self::Item>, 
1.0.0
[src]

Takes two iterators and creates a new iterator over both in sequence. Read more

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator
1.0.0
[src]

'Zips up' two iterators into a single iterator of pairs. Read more

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B, 
1.0.0
[src]

Takes a closure and creates an iterator which calls that closure on each element. Read more

fn for_each<F>(self, f: F) where
    F: FnMut(Self::Item), 
1.21.0
[src]

Calls a closure on each element of an iterator. Read more

fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    P: FnMut(&Self::Item) -> bool
1.0.0
[src]

Creates an iterator which uses a closure to determine if an element should be yielded. Read more

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>, 
1.0.0
[src]

Creates an iterator that both filters and maps. Read more

fn enumerate(self) -> Enumerate<Self>
1.0.0
[src]

Creates an iterator which gives the current iteration count as well as the next value. Read more

fn peekable(self) -> Peekable<Self>
1.0.0
[src]

Creates an iterator which can use peek to look at the next element of the iterator without consuming it. Read more

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool
1.0.0
[src]

Creates an iterator that [skip]s elements based on a predicate. Read more

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool
1.0.0
[src]

Creates an iterator that yields elements based on a predicate. Read more

fn skip(self, n: usize) -> Skip<Self>
1.0.0
[src]

Creates an iterator that skips the first n elements. Read more

fn take(self, n: usize) -> Take<Self>
1.0.0
[src]

Creates an iterator that yields its first n elements. Read more

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    F: FnMut(&mut St, Self::Item) -> Option<B>, 
1.0.0
[src]

An iterator adaptor similar to [fold] that holds internal state and produces a new iterator. Read more

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator
1.0.0
[src]

Creates an iterator that works like map, but flattens nested structure. Read more

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoIterator
1.29.0
[src]

Creates an iterator that flattens nested structure. Read more

fn fuse(self) -> Fuse<Self>
1.0.0
[src]

Creates an iterator which ends after the first [None]. Read more

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item), 
1.0.0
[src]

Do something with each element of an iterator, passing the value on. Read more

fn by_ref(&mut self) -> &mut Self
1.0.0
[src]

Borrows an iterator, rather than consuming it. Read more

#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B>(self) -> B where
    B: FromIterator<Self::Item>, 
1.0.0
[src]

Transforms an iterator into a collection. Read more

fn partition<B, F>(self, f: F) -> (B, B) where
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool
1.0.0
[src]

Consumes an iterator, creating two collections from it. Read more

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 
1.27.0
[src]

An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more

fn try_for_each<F, R>(&mut self, f: F) -> R where
    F: FnMut(Self::Item) -> R,
    R: Try<Ok = ()>, 
1.27.0
[src]

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more

fn fold<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 
1.0.0
[src]

An iterator method that applies a function, producing a single, final value. Read more

fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool
1.0.0
[src]

Tests if every element of the iterator matches a predicate. Read more

fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool
1.0.0
[src]

Tests if any element of the iterator matches a predicate. Read more

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool
1.0.0
[src]

Searches for an element of an iterator that satisfies a predicate. Read more

fn find_map<B, F>(&mut self, f: F) -> Option<B> where
    F: FnMut(Self::Item) -> Option<B>, 
1.30.0
[src]

Applies function to the elements of iterator and returns the first non-none result. Read more

fn position<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool
1.0.0
[src]

Searches for an element in an iterator, returning its index. Read more

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: ExactSizeIterator + DoubleEndedIterator
1.0.0
[src]

Searches for an element in an iterator from the right, returning its index. Read more

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord
1.0.0
[src]

Returns the maximum element of an iterator. Read more

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord
1.0.0
[src]

Returns the minimum element of an iterator. Read more

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 
1.6.0
[src]

Returns the element that gives the maximum value from the specified function. Read more

fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering
1.15.0
[src]

Returns the element that gives the maximum value with respect to the specified comparison function. Read more

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 
1.6.0
[src]

Returns the element that gives the minimum value from the specified function. Read more

fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering
1.15.0
[src]

Returns the element that gives the minimum value with respect to the specified comparison function. Read more

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator
1.0.0
[src]

Reverses an iterator's direction. Read more

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Iterator<Item = (A, B)>, 
1.0.0
[src]

Converts an iterator of pairs into a pair of containers. Read more

fn copied<'a, T>(self) -> Copied<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Copy
[src]

🔬 This is a nightly-only experimental API. (iter_copied)

Creates an iterator which copies all of its elements. Read more

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone
1.0.0
[src]

Creates an iterator which [clone]s all of its elements. Read more

fn cycle(self) -> Cycle<Self> where
    Self: Clone
1.0.0
[src]

Repeats an iterator endlessly. Read more

fn sum<S>(self) -> S where
    S: Sum<Self::Item>, 
1.11.0
[src]

Sums the elements of an iterator. Read more

fn product<P>(self) -> P where
    P: Product<Self::Item>, 
1.11.0
[src]

Iterates over the entire iterator, multiplying all the elements Read more

fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord
1.5.0
[src]

Lexicographically compares the elements of this Iterator with those of another. Read more

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 
1.5.0
[src]

Lexicographically compares the elements of this Iterator with those of another. Read more

fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 
1.5.0
[src]

Determines if the elements of this Iterator are equal to those of another. Read more

fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 
1.5.0
[src]

Determines if the elements of this Iterator are unequal to those of another. Read more

fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 
1.5.0
[src]

Determines if the elements of this Iterator are lexicographically less than those of another. Read more

fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 
1.5.0
[src]

Determines if the elements of this Iterator are lexicographically less or equal to those of another. Read more

fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 
1.5.0
[src]

Determines if the elements of this Iterator are lexicographically greater than those of another. Read more

fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 
1.5.0
[src]

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another. Read more

Auto Trait Implementations

impl<'a> !Sync for MoleculeIter<'a>

Blanket Implementations

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

type Error = !

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<I> IteratorRandom for I where
    I: Iterator
[src]

fn choose<R>(self, rng: &mut R) -> Option<Self::Item> where
    R: Rng + ?Sized
[src]

Choose one element at random from the iterator. If you have a slice, it's significantly faster to call the [choose] or [choose_mut] functions using the slice instead. Read more

fn choose_multiple_fill<R>(self, rng: &mut R, buf: &mut [Self::Item]) -> usize where
    R: Rng + ?Sized
[src]

Collects amount values at random from the iterator into a supplied buffer. Read more

fn choose_multiple<R>(self, rng: &mut R, amount: usize) -> Vec<Self::Item> where
    R: Rng + ?Sized
[src]

Collects amount values at random from the iterator into a vector. Read more

impl<T> ParallelBridge for T where
    T: Send + Iterator,
    <T as Iterator>::Item: Send
[src]

impl<T> Itertools for T where
    T: Iterator + ?Sized
[src]

fn interleave<J>(
    self,
    other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator<Item = Self::Item>, 
[src]

Alternate elements from two iterators until both have run out. Read more

fn interleave_shortest<J>(
    self,
    other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator<Item = Self::Item>, 
[src]

Alternate elements from two iterators until at least one of them has run out. Read more

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone
[src]

An iterator adaptor to insert a particular value between each element of the adapted iterator. Read more

fn zip_longest<J>(
    self,
    other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator
[src]

Create an iterator which iterates over both this and the specified iterator simultaneously, yielding pairs of two optional elements. Read more

fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator
[src]

Create an iterator which iterates over both this and the specified iterator simultaneously, yielding pairs of elements. Read more

fn batching<B, F>(self, f: F) -> Batching<Self, F> where
    F: FnMut(&mut Self) -> Option<B>, 
[src]

A “meta iterator adaptor”. Its closure receives a reference to the iterator and may pick off as many elements as it likes, to produce the next iterator element. Read more

fn tuple_windows<T>(self) -> TupleWindows<Self, T> where
    Self: Iterator<Item = <T as TupleCollect>::Item>,
    T: TupleCollect,
    <T as TupleCollect>::Item: Clone
[src]

Return an iterator over all contiguous windows producing tuples of a specific size (up to 4). Read more

fn tuples<T>(self) -> Tuples<Self, T> where
    Self: Iterator<Item = <T as TupleCollect>::Item>,
    T: TupleCollect, 
[src]

Return an iterator that groups the items in tuples of a specific size (up to 4). Read more

fn step(self, n: usize) -> Step<Self>[src]

Return an iterator adaptor that steps n elements in the base iterator for each iteration. Read more

fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F> where
    F: FnMut(T) -> U,
    Self: Iterator<Item = Result<T, E>>, 
[src]

Return an iterator adaptor that applies the provided closure to every Result::Ok value. Result::Err values are unchanged. Read more

fn merge<J>(self, other: J) -> Merge<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator<Item = Self::Item>,
    Self::Item: PartialOrd<Self::Item>, 
[src]

Return an iterator adaptor that merges the two base iterators in ascending order. If both base iterators are sorted (ascending), the result is sorted. Read more

fn merge_by<J, F>(
    self,
    other: J,
    is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F> where
    F: FnMut(&Self::Item, &Self::Item) -> bool,
    J: IntoIterator<Item = Self::Item>, 
[src]

Return an iterator adaptor that merges the two base iterators in order. This is much like .merge() but allows for a custom ordering. Read more

fn merge_join_by<J, F>(
    self,
    other: J,
    cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F> where
    F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
    J: IntoIterator
[src]

Create an iterator that merges items from both this and the specified iterator in ascending order. Read more

fn cartesian_product<J>(
    self,
    other: J
) -> Product<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator,
    Self::Item: Clone,
    <J as IntoIterator>::IntoIter: Clone
[src]

Return an iterator adaptor that iterates over the cartesian product of the element sets of two iterators self and J. Read more

fn coalesce<F>(self, f: F) -> Coalesce<Self, F> where
    F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>, 
[src]

Return an iterator adaptor that uses the passed-in closure to optionally merge together consecutive elements. Read more

fn dedup(self) -> Dedup<Self> where
    Self::Item: PartialEq<Self::Item>, 
[src]

Remove duplicates from sections of consecutive identical elements. If the iterator is sorted, all elements will be unique. Read more

fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool,
    Self: PeekingNext
[src]

Return an iterator adaptor that borrows from this iterator and takes items while the closure accept returns true. Read more

fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<Self, F> where
    F: FnMut(&Self::Item) -> bool,
    Self: Clone
[src]

Return an iterator adaptor that borrows from a Clone-able iterator to only pick off elements while the predicate accept returns true. Read more

fn while_some<A>(self) -> WhileSome<Self> where
    Self: Iterator<Item = Option<A>>, 
[src]

Return an iterator adaptor that filters Option<A> iterator elements and produces A. Stops on the first None encountered. Read more

fn tuple_combinations<T>(self) -> TupleCombinations<Self, T> where
    Self: Clone,
    T: HasCombination<Self>,
    Self::Item: Clone
[src]

Return an iterator adaptor that iterates over the combinations of the elements from an iterator. Read more

fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> where
    F: FnMut(usize) -> Self::Item
[src]

Return an iterator adaptor that pads the sequence to a minimum length of min by filling missing elements using a closure f. Read more

fn flatten(self) -> Flatten<Self, <Self::Item as IntoIterator>::IntoIter> where
    Self::Item: IntoIterator
[src]

Flatten an iterator of iterables into a single combined sequence of all the elements in the iterables. Read more

fn with_position(self) -> WithPosition<Self>[src]

Return an iterator adaptor that wraps each element in a Position to ease special-case handling of the first or last elements. Read more

fn positions<P>(self, predicate: P) -> Positions<Self, P> where
    P: FnMut(Self::Item) -> bool
[src]

Return an iterator adaptor that yields the indices of all elements satisfying a predicate, counted from the start of the iterator. Read more

fn update<F>(self, updater: F) -> Update<Self, F> where
    F: FnMut(&mut Self::Item), 
[src]

Return an iterator adaptor that applies a mutating function to each element before yielding it. Read more

fn next_tuple<T>(&mut self) -> Option<T> where
    Self: Iterator<Item = <T as TupleCollect>::Item>,
    T: TupleCollect, 
[src]

Advances the iterator and returns the next items grouped in a tuple of a specific size (up to 4). Read more

fn collect_tuple<T>(self) -> Option<T> where
    Self: Iterator<Item = <T as TupleCollect>::Item>,
    T: TupleCollect, 
[src]

Collects all items from the iterator into a tuple of a specific size (up to 4). Read more

fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)> where
    P: FnMut(&Self::Item) -> bool
[src]

Find the position and value of the first element satisfying a predicate. Read more

fn all_equal(&mut self) -> bool where
    Self::Item: PartialEq<Self::Item>, 
[src]

Check whether all elements compare equal. Read more

fn dropping(self, n: usize) -> Self[src]

Consume the first n elements from the iterator eagerly, and return the same iterator again. Read more

fn dropping_back(self, n: usize) -> Self where
    Self: DoubleEndedIterator
[src]

Consume the last n elements from the iterator eagerly, and return the same iterator again. Read more

fn foreach<F>(self, f: F) where
    F: FnMut(Self::Item), 
[src]

Run the closure f eagerly on each element of the iterator. Read more

fn concat(self) -> Self::Item where
    Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
    Self::Item: IntoIterator,
    Self::Item: Default
[src]

Combine all an iterator's elements into one element by using Extend. Read more

fn set_from<'a, A, J>(&mut self, from: J) -> usize where
    A: 'a,
    J: IntoIterator<Item = A>,
    Self: Iterator<Item = &'a mut A>, 
[src]

Assign to each reference in self from the from iterator, stopping at the shortest of the two iterators. Read more

fn format(self, sep: &str) -> Format<Self>[src]

Format all iterator elements, separated by sep. Read more

fn format_with<F>(self, sep: &str, format: F) -> FormatWith<Self, F> where
    F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>, 
[src]

Format all iterator elements, separated by sep. Read more

fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E> where
    F: FnMut(B, A) -> B,
    Self: Iterator<Item = Result<A, E>>, 
[src]

Fold Result values from an iterator. Read more

fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
    F: FnMut(B, A) -> B,
    Self: Iterator<Item = Option<A>>, 
[src]

Fold Option values from an iterator. Read more

fn fold1<F>(self, f: F) -> Option<Self::Item> where
    F: FnMut(Self::Item, Self::Item) -> Self::Item
[src]

Accumulator of the elements in the iterator. Read more

fn tree_fold1<F>(self, f: F) -> Option<Self::Item> where
    F: FnMut(Self::Item, Self::Item) -> Self::Item
[src]

Accumulate the elements in the iterator in a tree-like manner. Read more

fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B> where
    F: FnMut(B, Self::Item) -> FoldWhile<B>, 
[src]

An iterator method that applies a function, producing a single, final value. Read more

fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B) where
    A: Default + Extend<L>,
    B: Default + Extend<R>,
    F: Fn(Self::Item) -> Either<L, R>, 
[src]

Collect all iterator elements into one of two partitions. Unlike Iterator::partition, each partition may have a distinct type. Read more

fn minmax(self) -> MinMaxResult<Self::Item> where
    Self::Item: PartialOrd<Self::Item>, 
[src]

Return the minimum and maximum elements in the iterator. Read more

fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> where
    F: FnMut(&Self::Item) -> K,
    K: PartialOrd<K>, 
[src]

Return the minimum and maximum element of an iterator, as determined by the specified function. Read more

fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering
[src]

Return the minimum and maximum element of an iterator, as determined by the specified comparison function. Read more