Trait differential_dataflow::trace::Builder

source ·
pub trait Builder: Sized {
    type Input;
    type Time: Timestamp;
    type Output;

    // Required methods
    fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self;
    fn push(&mut self, chunk: &mut Self::Input);
    fn done(self, description: Description<Self::Time>) -> Self::Output;
    fn seal(
        chain: &mut Vec<Self::Input>,
        description: Description<Self::Time>,
    ) -> Self::Output;

    // Provided method
    fn new() -> Self { ... }
}
Expand description

Functionality for building batches from ordered update sequences.

Required Associated Types§

source

type Input

Input item type.

source

type Time: Timestamp

Timestamp type.

source

type Output

Output batch type.

Required Methods§

source

fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self

Allocates an empty builder with capacity for the specified keys, values, and updates.

They represent respectively the number of distinct key, (key, val), and total updates.

source

fn push(&mut self, chunk: &mut Self::Input)

Adds a chunk of elements to the batch.

Adds all elements from chunk to the builder and leaves chunk in an undefined state.

source

fn done(self, description: Description<Self::Time>) -> Self::Output

Completes building and returns the batch.

source

fn seal( chain: &mut Vec<Self::Input>, description: Description<Self::Time>, ) -> Self::Output

Builds a batch from a chain of updates corresponding to the indicated lower and upper bounds.

This method relies on the chain only containing updates greater or equal to the lower frontier, and not greater or equal to the upper frontier, as encoded in the description. Chains must also be sorted and consolidated.

Provided Methods§

source

fn new() -> Self

Allocates an empty builder.

Ideally we deprecate this and insist all non-trivial building happens via with_capacity().

Object Safety§

This trait is not object safe.

Implementors§

source§

impl<B: Builder> Builder for RcBuilder<B>

Functionality for building batches from ordered update sequences.

§

type Input = <B as Builder>::Input

§

type Time = <B as Builder>::Time

§

type Output = Rc<<B as Builder>::Output>

source§

impl<L, CI> Builder for OrdKeyBuilder<L, CI>
where L: Layout, CI: for<'a> BuilderInput<L::KeyContainer, L::ValContainer, Time = <L::Target as Update>::Time, Diff = <L::Target as Update>::Diff>, for<'a> L::KeyContainer: PushInto<CI::Key<'a>>, for<'a> <L::TimeContainer as BatchContainer>::ReadItem<'a>: IntoOwned<'a, Owned = <L::Target as Update>::Time>, for<'a> <L::DiffContainer as BatchContainer>::ReadItem<'a>: IntoOwned<'a, Owned = <L::Target as Update>::Diff>,

§

type Input = CI

§

type Time = <<L as Layout>::Target as Update>::Time

§

type Output = OrdKeyBatch<L>

source§

impl<L, CI> Builder for OrdValBuilder<L, CI>
where L: Layout, CI: for<'a> BuilderInput<L::KeyContainer, L::ValContainer, Time = <L::Target as Update>::Time, Diff = <L::Target as Update>::Diff>, for<'a> L::KeyContainer: PushInto<CI::Key<'a>>, for<'a> L::ValContainer: PushInto<CI::Val<'a>>, for<'a> <L::TimeContainer as BatchContainer>::ReadItem<'a>: IntoOwned<'a, Owned = <L::Target as Update>::Time>, for<'a> <L::DiffContainer as BatchContainer>::ReadItem<'a>: IntoOwned<'a, Owned = <L::Target as Update>::Diff>,

§

type Input = CI

§

type Time = <<L as Layout>::Target as Update>::Time

§

type Output = OrdValBatch<L>