Struct rin::ecs::streaming_iterator::Chain

pub struct Chain<A, B> { /* fields omitted */ }

A streaming iterator that concatenates two streaming iterators

Trait Implementations

impl<A, B> Debug for Chain<A, B> where
    B: Debug,
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<A, B> DoubleEndedStreamingIterator for Chain<A, B> where
    B: DoubleEndedStreamingIterator<Item = <A as StreamingIterator>::Item>,
    A: DoubleEndedStreamingIterator, 

pub fn advance_back(&mut self)

Advances the iterator to the next element from the back of the iterator.

pub fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc where
    F: FnMut(Acc, &<Chain<A, B> as StreamingIterator>::Item) -> Acc,
    Chain<A, B>: Sized, 

Reduces the iterator’s elements to a single, final value, starting from the back.

pub fn next_back(&mut self) -> Option<&Self::Item>

Advances the iterator and returns the next value from the back.

impl<A, B> DoubleEndedStreamingIteratorMut for Chain<A, B> where
    B: DoubleEndedStreamingIteratorMut<Item = <A as StreamingIterator>::Item>,
    A: DoubleEndedStreamingIteratorMut, 

pub fn rfold_mut<Acc, F>(self, init: Acc, f: F) -> Acc where
    F: FnMut(Acc, &mut <Chain<A, B> as StreamingIterator>::Item) -> Acc,
    Chain<A, B>: Sized, 

Reduces the iterator’s mutable elements to a single, final value, starting from the back.

pub fn next_back_mut(&mut self) -> Option<&mut Self::Item>

Advances the iterator and returns the next mutable value from the back.

impl<A, B> StreamingIterator for Chain<A, B> where
    B: StreamingIterator<Item = <A as StreamingIterator>::Item>,
    A: StreamingIterator, 

type Item = <A as StreamingIterator>::Item

The type of the elements being iterated over.

pub fn advance(&mut self)

Advances the iterator to the next element.

pub fn get(&self) -> Option<&<Chain<A, B> as StreamingIterator>::Item>

Returns a reference to the current element of the iterator.

pub fn fold<Acc, F>(self, init: Acc, f: F) -> Acc where
    F: FnMut(Acc, &<Chain<A, B> as StreamingIterator>::Item) -> Acc,
    Chain<A, B>: Sized, 

Reduces the iterator’s elements to a single, final value.

pub fn next(&mut self) -> Option<&Self::Item>

Advances the iterator and returns the next value.

pub fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

pub fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(&Self::Item) -> bool, 

Determines if all elements of the iterator satisfy a predicate.

pub fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(&Self::Item) -> bool, 

Determines if any elements of the iterator satisfy a predicate.

pub fn by_ref(&mut self) -> &mut Self

Borrows an iterator, rather than consuming it.

pub fn chain<I>(self, other: I) -> Chain<Self, I> where
    I: StreamingIterator<Item = Self::Item>, 

Consumes two iterators and returns a new iterator that iterates over both in sequence.

pub fn cloned(self) -> Cloned<Self> where
    Self::Item: Clone, 

Produces a normal, non-streaming, iterator by cloning the elements of this iterator.

pub fn count(self) -> usize

Consumes the iterator, counting the number of remaining elements and returning it.

pub fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

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

pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F> where
    F: FnMut(&Self::Item) -> Option<B>, 

Creates an iterator which both filters and maps by applying a closure to elements.

pub fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F> where
    F: FnMut(&Self::Item) -> J,
    J: StreamingIterator, 

Creates an iterator which flattens iterators obtained by applying a closure to elements. Note that the returned iterators must be streaming iterators.

pub fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F> where
    F: FnMut(&Self::Item) -> Option<B>, 

Creates a regular, non-streaming iterator which both filters and maps by applying a closure to elements.

pub fn find<F>(&mut self, f: F) -> Option<&Self::Item> where
    F: FnMut(&Self::Item) -> bool, 

Returns the first element of the iterator that satisfies the predicate.

pub fn fuse(self) -> Fuse<Self>

Creates an iterator which is “well behaved” at the beginning and end of iteration.

pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item), 

Call a closure on each element, passing the element on. The closure is called upon calls to advance or advance_back, and exactly once per element regardless of how many times (if any) get is called.

pub fn map<B, F>(self, f: F) -> Map<Self, B, F> where
    F: FnMut(&Self::Item) -> B, 

Creates an iterator which transforms elements of this iterator by passing them to a closure.

pub fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F> where
    F: FnMut(&Self::Item) -> B, 

Creates a regular, non-streaming iterator which transforms elements of this iterator by passing them to a closure.

pub fn map_ref<B, F>(self, f: F) -> MapRef<Self, F> where
    B: ?Sized,
    F: Fn(&Self::Item) -> &B, 

Creates an iterator which transforms elements of this iterator by passing them to a closure.

pub fn nth(&mut self, n: usize) -> Option<&Self::Item>

Consumes the first n elements of the iterator, returning the next one.

pub fn position<F>(&mut self, f: F) -> Option<usize> where
    F: FnMut(&Self::Item) -> bool, 

Returns the index of the first element of the iterator matching a predicate.

pub fn skip(self, n: usize) -> Skip<Self>

Creates an iterator which skips the first n elements.

pub fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Creates an iterator that skips initial elements matching a predicate.

pub fn take(self, n: usize) -> Take<Self>

Creates an iterator which only returns the first n elements.

pub fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Creates an iterator which only returns initial elements matching a predicate.

pub fn rev(self) -> Rev<Self> where
    Self: DoubleEndedStreamingIterator, 

Creates an iterator which returns elemens in the opposite order.

pub fn for_each<F>(self, f: F) where
    F: FnMut(&Self::Item), 

Calls a closure on each element of an iterator.

impl<A, B> StreamingIteratorMut for Chain<A, B> where
    B: StreamingIteratorMut<Item = <A as StreamingIterator>::Item>,
    A: StreamingIteratorMut, 

pub fn get_mut(
    &mut self
) -> Option<&mut <Chain<A, B> as StreamingIterator>::Item>

Returns a mutable reference to the current element of the iterator.

pub fn fold_mut<Acc, F>(self, init: Acc, f: F) -> Acc where
    F: FnMut(Acc, &mut <Chain<A, B> as StreamingIterator>::Item) -> Acc,
    Chain<A, B>: Sized, 

Reduces the iterator’s mutable elements to a single, final value.

pub fn next_mut(&mut self) -> Option<&mut Self::Item>

Advances the iterator and returns the next mutable value.

pub fn for_each_mut<F>(self, f: F) where
    F: FnMut(&mut Self::Item), 

Calls a closure on each mutable element of an iterator.

pub fn map_deref_mut<B, F>(self, f: F) -> MapDerefMut<Self, F> where
    F: FnMut(&mut Self::Item) -> B, 

Creates a regular, non-streaming iterator which transforms mutable elements of this iterator by passing them to a closure.

pub fn find_mut<F>(&mut self, f: F) -> Option<&mut Self::Item> where
    F: FnMut(&Self::Item) -> bool, 

Returns a mutable reference to the first element of the iterator that satisfies the predicate.