Struct streaming_iterator::ConvertRef

pub struct ConvertRef<'a, I, T: ?Sized> where
    I: Iterator<Item = &'a T>,
    T: 'a,  { /* fields omitted */ }

A streaming iterator which yields elements from an iterator of references.

Trait Implementations

impl<'a, I: Clone, T: Clone + ?Sized> Clone for ConvertRef<'a, I, T> where
    I: Iterator<Item = &'a T>,
    T: 'a, 

fn clone(&self) -> ConvertRef<'a, I, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, I: Debug, T: Debug + ?Sized> Debug for ConvertRef<'a, I, T> where
    I: Iterator<Item = &'a T>,
    T: 'a, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a, I, T: ?Sized> StreamingIterator for ConvertRef<'a, I, T> where
    I: Iterator<Item = &'a T>, 

type Item = T

The type of the elements being iterated over.

fn advance(&mut self)

Advances the iterator to the next element.

fn get(&self) -> Option<&T>

Returns a reference to the current element of the iterator.

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

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

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

fn fold<Acc, Fold>(self, init: Acc, f: Fold) -> Acc where
    Self: Sized,
    Fold: FnMut(Acc, &Self::Item) -> Acc, 

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

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

Advances the iterator and returns the next value.

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

Determines if all elements of the iterator satisfy a predicate.

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

Determines if any elements of the iterator satisfy a predicate.

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Borrows an iterator, rather than consuming it.

Important traits for Cloned<I>

impl<I> Iterator for Cloned<I> where
    I: StreamingIterator,
    I::Item: Clone,  type Item = I::Item;

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

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

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

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

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

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

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

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

fn fuse(self) -> Fuse<Self> where
    Self: Sized, 

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

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

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

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

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

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

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

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

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

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

Creates an iterator which skips the first n elements.

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

Creates an iterator that skips initial elements matching a predicate.

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

Creates an iterator which only returns the first n elements.

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

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

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

Creates an iterator which returns elemens in the opposite order.

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

Calls a closure on each element of an iterator.

impl<'a, I, T: ?Sized> DoubleEndedStreamingIterator for ConvertRef<'a, I, T> where
    I: DoubleEndedIterator<Item = &'a T>, 

fn advance_back(&mut self)

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

fn rfold<Acc, Fold>(self, init: Acc, f: Fold) -> Acc where
    Self: Sized,
    Fold: FnMut(Acc, &Self::Item) -> Acc, 

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

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

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