Trait rin::ecs::StreamingIteratorMut

pub trait StreamingIteratorMut: StreamingIterator {
    pub fn get_mut(&mut self) -> Option<&mut Self::Item>;

    pub fn next_mut(&mut self) -> Option<&mut Self::Item> { ... }
    pub fn fold_mut<B, F>(self, init: B, f: F) -> B
    where
        F: FnMut(B, &mut Self::Item) -> B,
    { ... }
    pub fn for_each_mut<F>(self, f: F)
    where
        F: FnMut(&mut Self::Item),
    { ... }
    pub fn map_deref_mut<B, F>(self, f: F) -> MapDerefMut<Self, F>
    where
        F: FnMut(&mut Self::Item) -> B,
    { ... }
    pub fn find_mut<F>(&mut self, f: F) -> Option<&mut Self::Item>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
}

An interface for dealing with mutable streaming iterators.

Required methods

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

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

The behavior of calling this method before advance has been called is unspecified.

Modifications through this reference may also have an unspecified effect on further iterator advancement, but implementations are encouraged to document this.

Loading content...

Provided methods

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

Advances the iterator and returns the next mutable value.

The behavior of calling this method after the end of the iterator has been reached is unspecified.

The default implementation simply calls advance followed by get_mut.

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

Reduces the iterator’s mutable elements to a single, final 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.

Loading content...

Implementations on Foreign Types

impl<'a, I> StreamingIteratorMut for &'a mut I where
    I: StreamingIteratorMut + ?Sized, 

pub fn get_mut(&mut self) -> Option<&mut <&'a mut I as StreamingIterator>::Item>

pub fn next_mut(
    &mut self
) -> Option<&mut <&'a mut I as StreamingIterator>::Item>

Loading content...

Implementors

impl<'a, I, T> StreamingIteratorMut for ConvertMut<'a, I, T> where
    T: ?Sized,
    I: Iterator<Item = &'a mut T>, 

pub fn get_mut(
    &mut self
) -> Option<&mut <ConvertMut<'a, I, T> as StreamingIterator>::Item>

pub fn fold_mut<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, &mut <ConvertMut<'a, I, T> as StreamingIterator>::Item) -> B,
    ConvertMut<'a, I, T>: Sized, 

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>

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, 

impl<I> StreamingIteratorMut for Convert<I> where
    I: Iterator, 

pub fn get_mut(&mut self) -> Option<&mut <I as Iterator>::Item>

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

impl<I> StreamingIteratorMut for Fuse<I> where
    I: StreamingIteratorMut, 

pub fn get_mut(&mut self) -> Option<&mut <I as StreamingIterator>::Item>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Fuse<I> as StreamingIterator>::Item) -> Acc,
    Fuse<I>: Sized, 

impl<I> StreamingIteratorMut for Rev<I> where
    I: DoubleEndedStreamingIteratorMut, 

pub fn get_mut(&mut self) -> Option<&mut <I as StreamingIterator>::Item>

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

impl<I> StreamingIteratorMut for Skip<I> where
    I: StreamingIteratorMut, 

pub fn get_mut(&mut self) -> Option<&mut <Skip<I> as StreamingIterator>::Item>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Skip<I> as StreamingIterator>::Item) -> Acc,
    Skip<I>: Sized, 

impl<I> StreamingIteratorMut for Take<I> where
    I: StreamingIteratorMut, 

pub fn get_mut(&mut self) -> Option<&mut <I as StreamingIterator>::Item>

impl<I, B, F> StreamingIteratorMut for FilterMap<I, B, F> where
    F: FnMut(&<I as StreamingIterator>::Item) -> Option<B>,
    I: StreamingIterator, 

pub fn get_mut(&mut self) -> Option<&mut B>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <FilterMap<I, B, F> as StreamingIterator>::Item) -> Acc,
    FilterMap<I, B, F>: Sized, 

impl<I, B, F> StreamingIteratorMut for Map<I, B, F> where
    F: FnMut(&<I as StreamingIterator>::Item) -> B,
    I: StreamingIterator, 

pub fn get_mut(&mut self) -> Option<&mut B>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Map<I, B, F> as StreamingIterator>::Item) -> Acc,
    Map<I, B, F>: Sized, 

impl<I, F> StreamingIteratorMut for Filter<I, F> where
    F: FnMut(&<I as StreamingIterator>::Item) -> bool,
    I: StreamingIteratorMut, 

pub fn get_mut(&mut self) -> Option<&mut <I as StreamingIterator>::Item>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Filter<I, F> as StreamingIterator>::Item) -> Acc,
    Filter<I, F>: Sized, 

impl<I, F> StreamingIteratorMut for Inspect<I, F> where
    F: FnMut(&<I as StreamingIterator>::Item),
    I: StreamingIteratorMut, 

pub fn get_mut(
    &mut self
) -> Option<&mut <Inspect<I, F> as StreamingIterator>::Item>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Inspect<I, F> as StreamingIterator>::Item) -> Acc,
    Inspect<I, F>: Sized, 

impl<I, F> StreamingIteratorMut for SkipWhile<I, F> where
    F: FnMut(&<I as StreamingIterator>::Item) -> bool,
    I: StreamingIteratorMut, 

pub fn get_mut(
    &mut self
) -> Option<&mut <SkipWhile<I, F> as StreamingIterator>::Item>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <SkipWhile<I, F> as StreamingIterator>::Item) -> Acc,
    SkipWhile<I, F>: Sized, 

impl<I, F> StreamingIteratorMut for TakeWhile<I, F> where
    F: FnMut(&<I as StreamingIterator>::Item) -> bool,
    I: StreamingIteratorMut, 

pub fn get_mut(&mut self) -> Option<&mut <I as StreamingIterator>::Item>

impl<I, J, F> StreamingIteratorMut for FlatMap<I, J, F> where
    F: FnMut(&<I as StreamingIterator>::Item) -> J,
    I: StreamingIterator,
    J: StreamingIteratorMut, 

pub fn get_mut(
    &mut self
) -> Option<&mut <FlatMap<I, J, F> as StreamingIterator>::Item>

pub fn fold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <FlatMap<I, J, F> as StreamingIterator>::Item) -> Acc,
    FlatMap<I, J, F>: Sized, 

impl<T> StreamingIteratorMut for Empty<T>

pub fn get_mut(&mut self) -> Option<&mut <Empty<T> as StreamingIterator>::Item>

impl<T> StreamingIteratorMut for Once<T>

pub fn get_mut(&mut self) -> Option<&mut <Once<T> as StreamingIterator>::Item>

impl<T> StreamingIteratorMut for Repeat<T>

pub fn get_mut(&mut self) -> Option<&mut <Repeat<T> as StreamingIterator>::Item>

impl<T, F> StreamingIteratorMut for FromFn<T, F> where
    F: FnMut() -> Option<T>, 

pub fn get_mut(
    &mut self
) -> Option<&mut <FromFn<T, F> as StreamingIterator>::Item>

impl<T, F> StreamingIteratorMut for OnceWith<T, F> where
    F: FnOnce() -> T, 

pub fn get_mut(
    &mut self
) -> Option<&mut <OnceWith<T, F> as StreamingIterator>::Item>

impl<T, F> StreamingIteratorMut for RepeatWith<T, F> where
    F: FnMut() -> T, 

pub fn get_mut(
    &mut self
) -> Option<&mut <RepeatWith<T, F> as StreamingIterator>::Item>

impl<T, F> StreamingIteratorMut for Successors<T, F> where
    F: FnMut(T) -> Option<T>, 

pub fn get_mut(
    &mut self
) -> Option<&mut <Successors<T, F> as StreamingIterator>::Item>

Loading content...