Struct differential_dataflow::collection::basic::BasicTrace

pub struct BasicTrace<K, T, V, L> {
    // some 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: LeastUpperBound + '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::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::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::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: LeastUpperBound + '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.