Struct Fold 

pub struct Fold<V, A, S, SF, OF> { /* private fields */ }

An aggregator that can be expressed as a fold of the input Z-set.

The Fold aggregator iterates over (key, weight) pairs with non-zero weights updating the value of an accumulator with a user-provided step function. The final aggregate is produced by applying a user-provided output function to the final value of the accumulator.

Type arguments

• A - accumulator
• S - semigroup structure used to compute aggregates piecewise
• SF - step function
• OF - output function

Implementations

impl<V, A, S, SF> Fold<V, A, S, SF, fn(A) -> A>

pub fn new(init: A, step: SF) -> Self

Create a Fold aggregator with initial accumulator value init, step function step, and identity output function.

This constructor caters for the common case when the final value of the accumulator is the desired aggregate, i.e., no output processing is required.

impl<V, A, S, SF, OF> Fold<V, A, S, SF, OF>

pub fn with_output(init: A, step: SF, output: OF) -> Self

Create a Fold aggregator with initial accumulator value init, step function step, and output function output.

Trait Implementations

impl<V, T, R, A, S, O, SF, OF> Aggregator<V, T, R> for Fold<V, A, S, SF, OF>

where T: Timestamp, V: DBData, R: DBWeight + MonoidValue, A: DBData, SF: Fn(&mut A, &V, R) + Clone + 'static, OF: Fn(A) -> O + Clone + 'static, S: Semigroup<A> + Clone + 'static, O: DBData,

type Accumulator = A

Accumulator type returned by Self::finalize.

type Output = O

Aggregate type produced by this aggregator.

type Semigroup = S

Semigroup structure over aggregate values.

fn aggregate<VTrait, RTrait>( &self, cursor: &mut dyn Cursor<VTrait, DynUnit, T, RTrait>, ) -> Option<Self::Accumulator>

where VTrait: DataTrait + ?Sized, RTrait: WeightTrait + ?Sized, V: Erase<VTrait>, R: Erase<RTrait>,

Takes a cursor pointing to the first key of a Z-set and outputs an aggregate of the Z-set.

fn finalize(&self, acc: Self::Accumulator) -> Self::Output

Compute the final value of the aggregate.

fn aggregate_and_finalize<KTrait, RTrait>( &self, cursor: &mut dyn Cursor<KTrait, DynUnit, T, RTrait>, ) -> Option<Self::Output>

where KTrait: DataTrait + ?Sized, RTrait: WeightTrait + ?Sized, K: Erase<KTrait>, R: Erase<RTrait>,

Applies aggregate to cursor followed by finalize.

impl<V: Clone, A: Clone, S: Clone, SF: Clone, OF: Clone> Clone for Fold<V, A, S, SF, OF>

fn clone(&self) -> Fold<V, A, S, SF, OF>

Returns a duplicate of the value.

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

Performs copy-assignment from source.