Trait gll_pg_core::StreamingIterator

pub trait StreamingIterator {
    type Item: ?Sized;

    // Required methods
    fn advance(&mut self);
    fn get(&self) -> Option<&Self::Item>;

    // Provided methods
    fn next(&mut self) -> Option<&Self::Item> { ... }
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn is_done(&self) -> bool { ... }
    fn all<F>(&mut self, f: F) -> bool
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn any<F>(&mut self, f: F) -> bool
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn by_ref(&mut self) -> &mut Self
       where Self: Sized { ... }
    fn chain<I>(self, other: I) -> Chain<Self, I>
       where Self: Sized,
             I: StreamingIterator<Item = Self::Item> { ... }
    fn cloned(self) -> Cloned<Self>
       where Self: Sized,
             Self::Item: Clone { ... }
    fn copied(self) -> Copied<Self>
       where Self: Sized,
             Self::Item: Copy { ... }
    fn count(self) -> usize
       where Self: Sized { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> Option<B> { ... }
    fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>
       where Self: Sized,
             J: StreamingIterator,
             F: FnMut(&Self::Item) -> J { ... }
    fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> Option<B> { ... }
    fn find<F>(&mut self, f: F) -> Option<&Self::Item>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn fuse(self) -> Fuse<Self>
       where Self: Sized { ... }
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
       where F: FnMut(&Self::Item),
             Self: Sized { ... }
    fn map<B, F>(self, f: F) -> Map<Self, B, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> B { ... }
    fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> B { ... }
    fn map_ref<B, F>(self, f: F) -> MapRef<Self, F>
       where Self: Sized,
             F: Fn(&Self::Item) -> &B,
             B: ?Sized { ... }
    fn nth(&mut self, n: usize) -> Option<&Self::Item> { ... }
    fn position<F>(&mut self, f: F) -> Option<usize>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn skip(self, n: usize) -> Skip<Self>
       where Self: Sized { ... }
    fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn take(self, n: usize) -> Take<Self>
       where Self: Sized { ... }
    fn take_while<F>(self, f: F) -> TakeWhile<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn rev(self) -> Rev<Self>
       where Self: Sized + DoubleEndedStreamingIterator { ... }
    fn fold<B, F>(self, init: B, f: F) -> B
       where Self: Sized,
             F: FnMut(B, &Self::Item) -> B { ... }
    fn for_each<F>(self, f: F)
       where Self: Sized,
             F: FnMut(&Self::Item) { ... }
}

Re-exported streaming_iterator structs to avoid requiring dependency of generated code on it. An interface for dealing with streaming iterators.

Required Associated Types

type Item: ?Sized

The type of the elements being iterated over.

Required Methods

fn advance(&mut self)

Advances the iterator to the next element.

Iterators start just before the first element, so this should be called before get.

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

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

Returns a reference to the current element of the iterator.

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

Provided Methods

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

Advances the iterator and returns the next 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.

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

Returns the bounds on the remaining length of the iterator.

fn is_done(&self) -> bool

Checks if get() will return None.

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.

This is useful to allow the application of iterator adaptors while still retaining ownership of the original adaptor.

fn chain<I>(self, other: I) -> Chain<Self, I>

where Self: Sized, I: StreamingIterator<Item = Self::Item>,

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

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 copied(self) -> Copied<Self>

where Self: Sized, Self::Item: Copy,

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

fn count(self) -> usize

where Self: Sized,

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

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 flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>

where Self: Sized, J: StreamingIterator, F: FnMut(&Self::Item) -> J,

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

fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> Option<B>,

Creates a regular, non-streaming 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.

The behavior of calling get before iteration has been started, and of continuing to call advance after get has returned None is normally unspecified, but this guarantees that get will return None in both cases.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where F: FnMut(&Self::Item), Self: Sized,

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.

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_deref<B, F>(self, f: F) -> MapDeref<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> B,

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

fn map_ref<B, F>(self, f: F) -> MapRef<Self, F>

where Self: Sized, F: Fn(&Self::Item) -> &B, B: ?Sized,

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

Unlike map, this method takes a closure that returns a reference into the original value.

The mapping function is only guaranteed to be called at some point before an element is actually consumed. This allows an expensive mapping function to be ignored during skipping (e.g. nth).

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 fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, &Self::Item) -> B,

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

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(&Self::Item),

Calls a closure on each element of an iterator.

Implementations on Foreign Types

impl<'a, I> StreamingIterator for &'a mut I

where I: StreamingIterator + ?Sized,

type Item = <I as StreamingIterator>::Item

fn advance(&mut self)

fn is_done(&self) -> bool

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

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

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

Implementors

impl<'a, I, T> StreamingIterator for ConvertMut<'a, I, T>

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

type Item = T

impl<'a, I, T> StreamingIterator for ConvertRef<'a, I, T>

where I: Iterator<Item = &'a T>, T: ?Sized,

type Item = T

impl<A, B> StreamingIterator for Chain<A, B>

where A: StreamingIterator, B: StreamingIterator<Item = <A as StreamingIterator>::Item>,

type Item = <A as StreamingIterator>::Item

impl<I> StreamingIterator for Convert<I>

where I: Iterator,

type Item = <I as Iterator>::Item

impl<I> StreamingIterator for Flatten<I>

where I: StreamingIteratorMut, <I as StreamingIterator>::Item: StreamingIterator,

type Item = <<I as StreamingIterator>::Item as StreamingIterator>::Item

impl<I> StreamingIterator for Fuse<I>

where I: StreamingIterator,

type Item = <I as StreamingIterator>::Item

impl<I> StreamingIterator for Rev<I>

where I: DoubleEndedStreamingIterator,

type Item = <I as StreamingIterator>::Item

impl<I> StreamingIterator for Skip<I>

where I: StreamingIterator,

type Item = <I as StreamingIterator>::Item

impl<I> StreamingIterator for Take<I>

where I: StreamingIterator,

type Item = <I as StreamingIterator>::Item

impl<I, B, F> StreamingIterator for FilterMap<I, B, F>

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

type Item = B

impl<I, B, F> StreamingIterator for Map<I, B, F>

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

type Item = B

impl<I, B, F> StreamingIterator for MapRef<I, F>

where I: StreamingIterator, F: Fn(&<I as StreamingIterator>::Item) -> &B, B: ?Sized,

type Item = B

impl<I, F> StreamingIterator for Filter<I, F>

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

type Item = <I as StreamingIterator>::Item

impl<I, F> StreamingIterator for Inspect<I, F>

where I: StreamingIterator, F: FnMut(&<I as StreamingIterator>::Item),

type Item = <I as StreamingIterator>::Item

impl<I, F> StreamingIterator for SkipWhile<I, F>

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

type Item = <I as StreamingIterator>::Item

impl<I, F> StreamingIterator for TakeWhile<I, F>

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

type Item = <I as StreamingIterator>::Item

impl<I, J, F> StreamingIterator for FlatMap<I, J, F>

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

type Item = <J as StreamingIterator>::Item

impl<T> StreamingIterator for WindowsMut<'_, T>

type Item = [T]

impl<T> StreamingIterator for Empty<T>

type Item = T

impl<T> StreamingIterator for Once<T>

type Item = T

impl<T> StreamingIterator for Repeat<T>

type Item = T

impl<T, F> StreamingIterator for FromFn<T, F>

where F: FnMut() -> Option<T>,

type Item = T

impl<T, F> StreamingIterator for OnceWith<T, F>

where F: FnOnce() -> T,

type Item = T

impl<T, F> StreamingIterator for RepeatWith<T, F>

where F: FnMut() -> T,

type Item = T

impl<T, F> StreamingIterator for Successors<T, F>

where F: FnMut(T) -> Option<T>,

type Item = T