Trait differential_dataflow::trace::Builder

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,
        lower: Antichain<Self::Time>,
        upper: Antichain<Self::Time>,
        since: Antichain<Self::Time>,
    ) -> Self::Output;

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

Functionality for building batches from ordered update sequences.

Required Associated Types

type Input

Input item type.

type Time: Timestamp

Timestamp type.

type Output

Output batch type.

Required Methods

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.

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.

fn done( self, lower: Antichain<Self::Time>, upper: Antichain<Self::Time>, since: Antichain<Self::Time>, ) -> Self::Output

Completes building and returns the batch.

Provided Methods

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

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>

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>

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>