Struct differential_dataflow::trace::layers::ordered::OrderedBuilder

pub struct OrderedBuilder<K, L, O = usize, C = Vec<K>>where
    K: Ord,
    C: BatchContainer<Item = K>,
    O: OrdOffset,{
    pub keys: C,
    pub offs: Vec<O>,
    pub vals: L,
}

Assembles a layer of this

Fields

keys: C

Keys

offs: Vec<O>

Offsets

vals: L

The next layer down

Implementations

impl<K, L, O, C> OrderedBuilder<K, L, O, C>where K: Ord + Clone, C: BatchContainer<Item = K>, L: MergeBuilder, O: OrdOffset,

pub fn merge_step( &mut self, other1: (&<Self as Builder>::Trie, &mut usize, usize), other2: (&<Self as Builder>::Trie, &mut usize, usize) )

Performs one step of merging.

Trait Implementations

impl<K, L, O, C> Builder for OrderedBuilder<K, L, O, C>where K: Ord + Clone, C: BatchContainer<Item = K>, L: Builder, O: OrdOffset,

type Trie = OrderedLayer<K, <L as Builder>::Trie, O, C>

The type of collection produced.

fn boundary(&mut self) -> usize

Requests a commitment to the offset of the current-most sub-collection.

fn done(self) -> Self::Trie

Finalizes the building process and returns the collection.

impl<K, L, O, C> MergeBuilder for OrderedBuilder<K, L, O, C>where K: Ord + Clone, C: BatchContainer<Item = K>, L: MergeBuilder, O: OrdOffset,

fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self

Allocates an instance of the builder with sufficient capacity to contain the merged data.

fn copy_range(&mut self, other: &Self::Trie, lower: usize, upper: usize)

Copies sub-collections of other into this collection.

fn push_merge( &mut self, other1: (&Self::Trie, usize, usize), other2: (&Self::Trie, usize, usize) ) -> usize

Merges two sub-collections into one sub-collection.

impl<K, L, O, C> TupleBuilder for OrderedBuilder<K, L, O, C>where K: Ord + Clone, C: BatchContainer<Item = K>, L: TupleBuilder, O: OrdOffset,

type Item = (K, <L as TupleBuilder>::Item)

The type of item accepted for construction.

fn new() -> Self

Allocates a new builder.

fn with_capacity(cap: usize) -> Self

Allocates a new builder with capacity for at least cap tuples.

fn push_tuple(&mut self, (key, val): (K, L::Item))

Inserts a new into the collection.