Struct rayon::iter::reduce::ReduceConsumer

struct ReduceConsumer<'r, R, ID> {
    identity: &'r ID,
    reduce_op: &'r R,
}

Fields

identity: &'r ID

reduce_op: &'r R

Trait Implementations

impl<'r, R, ID> Clone for ReduceConsumer<'r, R, ID>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'r, R, ID, T> Consumer<T> for ReduceConsumer<'r, R, ID>

where R: Fn(T, T) -> T + Sync, ID: Fn() -> T + Sync, T: Send,

type Folder = ReduceFolder<'r, R, T>

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

type Reducer = ReduceConsumer<'r, R, ID>

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

type Result = T

The type of result that this consumer will ultimately produce.

fn split_at(self, _index: usize) -> (Self, Self, Self)

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.

impl<'r, R, ID, T> Reducer<T> for ReduceConsumer<'r, R, ID>

where R: Fn(T, T) -> T + Sync,

fn reduce(self, left: T, right: T) -> T

Reduce two final results into one; this is executed after a split.

impl<'r, R, ID, T> UnindexedConsumer<T> for ReduceConsumer<'r, R, ID>

where R: Fn(T, T) -> T + Sync, ID: Fn() -> T + Sync, T: Send,

fn split_off_left(&self) -> Self

Splits off a “left” consumer and returns it. The self consumer should then be used to consume the “right” portion of the data. (The ordering matters for methods like find_first – values produced by the returned value are given precedence over values produced by self.) Once the left and right halves have been fully consumed, you should reduce the results with the result of to_reducer.

fn to_reducer(&self) -> Self::Reducer

Creates a reducer that can be used to combine the results from a split consumer.

impl<'r, R, ID> Copy for ReduceConsumer<'r, R, ID>