Struct differential_dataflow::collection::basic::BasicTrace

pub struct BasicTrace<K, T, V, L> { /* fields omitted */ }

A collection of values indexed by key and time.

A BasicTrace maintains a mapping from keys of type K to offsets into a vector of ListEntry structs, which are themselves linked-list entries of pairs of a time T and an offset into a TimeEntry struct, which wraps a Vec<(V, i32)>.

This trie structure is easy to update as new times arrive: the new data form a new TimeEntry, and any involved keys have elements added to their linked lists.

At the same time, its performance can degrade after large numbers of updates as the data associated with a given key becomes more and more diffuse. The trace also has no support for compaction.

Methods

impl<K: Eq, L: Lookup<K, Offset>, T, V> BasicTrace<K, T, V, L>

fn new(l: L) -> BasicTrace<K, T, V, L>

Allocates a new basic trace.

Trait Implementations

impl<K, V, L, T> Trace for BasicTrace<K, T, V, L> where
    K: Data,
    V: Data,
    L: Lookup<K, Offset> + 'static,
    T: Lattice + 'static, 

type Key = K

The data-parallel key.

type Index = T

Timestamp for changes to the collection.

type Value = V

Values associated with each key.

fn set_difference(&mut self, time: T, accumulation: Compact<K, V>)

Introduces differences in accumulation at time.

fn trace<'a>(
    &'a self,
    key: &Self::Key
) -> <&'a Self as TraceRef<'a, Self::Key, Self::Index, Self::Value>>::TIterator

Iterates over times and differences for a specified key.

fn get_difference<'a>(
    &'a self,
    key: &Self::Key,
    time: &Self::Index
) -> Option<<&'a Self as TraceRef<'a, Self::Key, Self::Index, Self::Value>>::VIterator>

Iterates over differences for a specified key and time.

fn get_collection<'a>(
    &'a mut self,
    key: &Self::Key,
    time: &Self::Index
) -> CollectionIterator<<&'a Self as TraceRef<'a, Self::Key, Self::Index, Self::Value>>::VIterator>

Accumulates differences for key at times less than or equal to time.

fn interesting_times<'a>(
    &'a self,
    key: &Self::Key,
    time: &Self::Index,
    stash: &mut Vec<Self::Index>
)

Populates stash with times for key, closes under least upper bound.

impl<'a, K, V, L, T> TraceRef<'a, K, T, V> for &'a BasicTrace<K, T, V, L> where
    K: Data + 'a,
    V: Data + 'a,
    L: Lookup<K, Offset> + 'a,
    T: Lattice + 'a, 

type VIterator = DifferenceIterator<'a, V>

Iterator over references to values.

type TIterator = TraceIterator<'a, K, T, V, L>

Iterator over times and VIterators.

fn trace(self, key: &K) -> Self::TIterator

Iterates over differences associated with the key.