Struct differential_dataflow::trace::implementations::ord::OrdKeyBatch

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

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

Fields

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

Where all the dataz is.

desc: Description<T>

Description of the update times this layer represents.

Trait Implementations

impl<K, T, R> BatchReader<K, (), T, R> for OrdKeyBatch<K, T, R> where
    K: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + 'static,
    R: Monoid, 

type Cursor = OrdKeyCursor<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 is_empty(&self) -> bool

True if the batch is empty.

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, T, R> Batch<K, (), T, R> for OrdKeyBatch<K, T, R> where
    K: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + 'static,
    R: Monoid, 

type Batcher = MergeBatcher<K, (), T, R, Self>

A type used to assemble batches from disordered updates.

type Builder = OrdKeyBuilder<K, T, R>

A type used to assemble batches from ordered update sequences.

type Merger = OrdKeyMerger<K, T, R>

A type used to progressively merge batches.

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

Initiates the merging of consecutive batches.

impl<K, T, R> Builder<K, (), T, R, OrdKeyBatch<K, T, R>> for OrdKeyBuilder<K, T, R> where
    K: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + 'static,
    R: Monoid, 

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, _, time, diff): (K, (), T, R))

Adds an element to the batch.

fn done(self, lower: &[T], upper: &[T], since: &[T]) -> OrdKeyBatch<K, 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.

impl<K, T, R> Merger<K, (), T, R, OrdKeyBatch<K, T, R>> for OrdKeyMerger<K, T, R> where
    K: Ord + Clone + 'static,
    T: Lattice + Ord + Clone + 'static,
    R: Monoid, 

fn new(batch1: &OrdKeyBatch<K, T, R>, batch2: &OrdKeyBatch<K, T, R>) -> Self

Creates a new merger to merge the supplied batches.

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

Extracts merged results.

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

Perform some amount of work, decrementing fuel.

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

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

Formats the value using the given formatter.

impl<K: Ord, T: Lattice, R> Abomonation for OrdKeyBatch<K, T, R> where
    OrderedLayer<K, OrderedLeaf<T, R>>: Abomonation,
    K: 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.