Struct differential_dataflow::collection::count::Count

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

A trace specialized for the value type ().

This trace does not need to represent a variable number of values associated with each key, and instead needs only one weight per timestamp.

Methods

impl<K, L, T> Count<K, T, L> where
    K: Data + Ord + 'static,
    L: Lookup<K, Offset> + 'static,
    T: Lattice + 'static, 

fn get_count(&self, key: &K, time: &T) -> i32

Recovers the count for the () value for a key at a time.

impl<K: Eq, L: Lookup<K, Offset>, T> Count<K, T, L>

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

Allocates a new Count from a supplied lookup.

Trait Implementations

impl<K, L, T> Trace for Count<K, T, L> where
    K: Data + Ord + 'static,
    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 = ()

Values associated with each key.

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

Installs a supplied set of keys and values as the differences for 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, L, T> TraceRef<'a, K, T, ()> for &'a Count<K, T, L> where
    K: Ord + 'a,
    L: Lookup<K, Offset> + 'a,
    T: Lattice + 'a, 

type VIterator = WeightIterator<'a>

Iterator over references to values.

type TIterator = CountIterator<'a, K, T, L>

Iterator over times and VIterators.

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

Iterates over differences associated with the key.