Struct differential_dataflow::trace::implementations::spine::Spine

pub struct Spine<K, V, T: Lattice + Ord, R: Diff, B: Batch<K, V, T, R>> { /* fields omitted */ }

An append-only collection of update tuples.

A spine maintains a small number of immutable collections of update tuples, merging the collections when two have similar sizes. In this way, it allows the addition of more tuples, which may then be merged with other immutable collections.

Trait Implementations

impl<K: Debug, V: Debug, T: Debug + Lattice + Ord, R: Debug + Diff, B: Debug + Batch<K, V, T, R>> Debug for Spine<K, V, T, R, B>

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

Formats the value using the given formatter.

impl<K, V, T, R, B> TraceReader<K, V, T, R> for Spine<K, V, T, R, B> where
    K: Ord + Clone,
    V: Ord + Clone,
    T: Lattice + Ord + Clone,
    R: Diff,
    B: Batch<K, V, T, R> + Clone + 'static, 

type Batch = B

The type of an immutable collection of updates.

type Cursor = CursorList<K, V, T, R, <B as BatchReader<K, V, T, R>>::Cursor>

The type used to enumerate the collections contents.

fn cursor_through(
    &mut self,
    upper: &[T]
) -> Option<(Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage)>

Acquires a cursor to the restriction of the collection's contents to updates at times not greater or equal to an element of upper.

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

Advances the frontier of times the collection must be correctly accumulable through.

fn advance_frontier(&mut self) -> &[T]

Reports the frontier from which all time comparisions should be accurate.

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

Advances the frontier that may be used in cursor_through.

fn distinguish_frontier(&mut self) -> &[T]

Reports the frontier from which the collection may be subsetted.

fn map_batches<F: FnMut(&Self::Batch)>(&mut self, f: F)

Maps some logic across the batches the collection manages.

fn cursor(
    &mut self
) -> (Self::Cursor, <Self::Cursor as Cursor<Key, Val, Time, R>>::Storage)

Provides a cursor over updates contained in the trace.

impl<K, V, T, R, B> Trace<K, V, T, R> for Spine<K, V, T, R, B> where
    K: Ord + Clone,
    V: Ord + Clone,
    T: Lattice + Ord + Clone,
    R: Diff,
    B: Batch<K, V, T, R> + Clone + 'static, 

fn new() -> Self

Allocates a new empty trace.

fn insert(&mut self, batch: Self::Batch)

Introduces a batch of updates to the trace.