Struct Filter 

pub struct Filter<I, P> { /* private fields */ }

An adapter for filtering items in an OutputIterator. This is created by the filter method on OutputIterator. See its documentation for more.

Trait Implementations

impl<I, P> OutputIterator for Filter<I, P>

where I: OutputIterator, P: FnMut(&I::Item) -> bool,

type Item = <I as OutputIterator>::Item

The type of items yielded by this iterator.

type Output = <I as OutputIterator>::Output

The type of the intermediate output produced by this iterator.

type AfterOutput = Filter<<I as OutputIterator>::AfterOutput, P>

The type of the iterator after the intermediate output is produced.

fn next(self) -> OutputIteratorVariant<Self>

Advances the iterator, returning either the next item or the intermediate output.

fn into_iter(self, buf: &mut Self::Output) -> IntoIter<'_, Self>

Converts this OutputIterator into a standard iterator, using a mutable buffer to store the intermediate output. Upon completion, output buffer will be overridden with the output of the iterator.

fn into_iter_option( self, buf: &mut Option<Self::Output>, ) -> IntoIterOption<'_, Self>

Converts this OutputIterator into an iterator, and a reference to the optional buffer. At the moment of creation, the buffer will be None, and upon completion it will be Some with output of the iterator.

fn ignore_output(self) -> IgnoreOutput<Self>

Converts this OutputIterator into an iterator that ignores the intermediate output.

fn until_output( self, f: impl FnMut(Self::Item), ) -> (Self::AfterOutput, Self::Output)

Processes items until the intermediate output is encountered, calling closure for each yielded item.

fn until_output_iter<F>(self, f: F) -> (Self::AfterOutput, Self::Output)

where F: FnOnce(&mut UntilOutput<Self>),

Similar to until_output, but instead gives an iterator when it is more convenient to use it. Iterator only yields items until the intermediate output has been received, and no more.

fn foreach(self, f: impl FnMut(Self::Item)) -> Self::Output

Iterates over all items, applying a closure to each item. Returns produced output.

fn map_output<B, F>(self, f: F) -> MapOutput<Self, F>

where F: FnOnce(Self::Output) -> B,

Maps the intermediate output using the provided function.

fn map<B, F>(self, f: F) -> Map<Self, F>

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

Takes a closure and creates an output iterator which calls that closure on each Item.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where P: FnMut(&Self::Item) -> bool,

Filters out the Items on which the predicate returns false.