Struct differential_dataflow::trace::implementations::ord::OrdValBatch

pub struct OrdValBatch<K: Ord, V: Ord, T: Lattice, R> {
    pub layer: OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>,
    pub desc: Description<T>,
}

An immutable collection of update tuples, from a contiguous interval of logical times.

Fields

layer: OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>

Where all the dataz is.

desc: Description<T>

Description of the update times this layer represents.

Trait Implementations

impl<K: Debug + Ord, V: Debug + Ord, T: Debug + Lattice, R: Debug> Debug for OrdValBatch<K, V, T, R>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<K: Ord, V: Ord, T: Lattice, R> Abomonation for OrdValBatch<K, V, T, R> where
    OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>: Abomonation,
    K: Abomonation,
    V: Abomonation,
    T: Abomonation,
    R: Abomonation,
    Description<T>: Abomonation, 

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> Result<()>

Write any additional information about &self beyond its binary representation.

fn extent(&self) -> usize

Reports the number of further bytes required to entomb self.

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

Recover any information for &mut self not evident from its binary representation.

impl<K, V, T, R> BatchReader<K, V, T, R> for OrdValBatch<K, V, T, R> where
    K: Ord + Clone + 'static,
    V: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + 'static,
    R: Diff, 

type Cursor = OrdValCursor<V, T, R>

The type used to enumerate the batch's contents.

fn cursor(&self) -> Self::Cursor

Acquires a cursor to the batch's contents.

fn len(&self) -> usize

The number of updates in the batch.

fn description(&self) -> &Description<T>

Describes the times of the updates in the batch.

fn lower(&self) -> &[T]

All times in the batch are greater or equal to an element of lower.

fn upper(&self) -> &[T]

All times in the batch are not greater or equal to any element of upper.

impl<K, V, T, R> Batch<K, V, T, R> for OrdValBatch<K, V, T, R> where
    K: Ord + Clone + 'static,
    V: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + Debug + 'static,
    R: Diff, 

type Batcher = MergeBatcher<K, V, T, R, Self>

A type used to assemble batches from disordered updates.

type Builder = OrdValBuilder<K, V, T, R>

A type used to assemble batches from ordered update sequences.

type Merger = OrdValMerger<K, V, T, R>

A type used to progressively merge batches.

fn merge(&self, other: &Self) -> Self

Merges two consecutive batches.

fn begin_merge(&self, other: &Self) -> Self::Merger

Initiates the merging of consecutive batches.

fn advance_mut(&mut self, frontier: &[T])

Advance times to frontier updating this batch.

fn advance_ref(&self, frontier: &[T]) -> Self where
    K: Ord + Clone,
    V: Ord + Clone,
    T: Lattice + Ord + Clone,
    R: Diff, 

Advance times to frontier creating a new batch.

impl<K, V, T, R> Merger<K, V, T, R, OrdValBatch<K, V, T, R>> for OrdValMerger<K, V, T, R> where
    K: Ord + Clone + 'static,
    V: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + Debug + 'static,
    R: Diff, 

fn done(self) -> OrdValBatch<K, V, T, R>

Extracts merged results.

fn work(
    &mut self,
    source1: &OrdValBatch<K, V, T, R>,
    source2: &OrdValBatch<K, V, T, R>,
    frontier: &Option<Vec<T>>,
    fuel: &mut usize
)

Perform some amount of work, decrementing fuel.

impl<K, V, T, R> Builder<K, V, T, R, OrdValBatch<K, V, T, R>> for OrdValBuilder<K, V, T, R> where
    K: Ord + Clone + 'static,
    V: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + Debug + 'static,
    R: Diff, 

fn new() -> Self

Allocates an empty builder.

fn with_capacity(cap: usize) -> Self

Allocates an empty builder with some capacity.

fn push(&mut self, (key, val, time, diff): (K, V, T, R))

Adds an element to the batch.

fn done(self, lower: &[T], upper: &[T], since: &[T]) -> OrdValBatch<K, V, T, R>

Completes building and returns the batch.

fn extend<I: Iterator<Item = (K, V, T, R)>>(&mut self, iter: I)

Adds an ordered sequence of elements to the batch.