Struct rayon::iter::positions::PositionsConsumer

struct PositionsConsumer<'p, C, P> {
    base: C,
    predicate: &'p P,
    offset: usize,
}

//////////////////////////////////////////////////////////////////////// Consumer implementation

Fields

base: C

predicate: &'p P

offset: usize

Implementations

impl<'p, C, P> PositionsConsumer<'p, C, P>

fn new(base: C, predicate: &'p P, offset: usize) -> Self

Trait Implementations

impl<'p, T, C, P> Consumer<T> for PositionsConsumer<'p, C, P>

where C: Consumer<usize>, P: Fn(T) -> bool + Sync,

type Folder = PositionsFolder<'p, <C as Consumer<usize>>::Folder, P>

The type of folder that this consumer can be converted into.

type Reducer = <C as Consumer<usize>>::Reducer

The type of reducer that is produced if this consumer is split.

type Result = <C as Consumer<usize>>::Result

The type of result that this consumer will ultimately produce.

fn split_at(self, index: usize) -> (Self, Self, C::Reducer)

Divide the consumer into two consumers, one processing items 0..index and one processing items from index... Also produces a reducer that can be used to reduce the results at the end.

fn into_folder(self) -> Self::Folder

Convert the consumer into a folder that can consume items sequentially, eventually producing a final result.

fn full(&self) -> bool

Hint whether this Consumer would like to stop processing further items, e.g. if a search has been completed.