Struct RecordedUpdates 

pub struct RecordedUpdates<U: ColumnarUpdate> {
    pub updates: Updates<U>,
    pub records: usize,
    pub consolidated: bool,
}

A thin wrapper around Updates that tracks the pre-consolidation record count for timely’s exchange accounting. This wrapper is the stream container type; the TrieChunker strips it, passing bare UpdatesTyped into the merge batcher.

Fields

updates: Updates<U>

The trie of (key, val, time, diff) updates.

records: usize

Number of records in updates before consolidation.

consolidated: bool

Whether updates is known to be sorted and consolidated (no duplicate (key, val, time) triples, no zero diffs).

Trait Implementations

impl<U: ColumnarUpdate> Accountable for RecordedUpdates<U>

fn record_count(&self) -> i64

The number of records

fn is_empty(&self) -> bool

Determine if this contains any updates, corresponding to update_count() == 0. It is a correctness error for this to be anything other than self.record_count() == 0.

impl<U: ColumnarUpdate> Clone for RecordedUpdates<U>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<U: ColumnarUpdate> ContainerBytes for RecordedUpdates<U>

fn from_bytes(bytes: Bytes) -> Self

Wrap bytes as Self.

fn length_in_bytes(&self) -> usize

The number of bytes required to serialize the data.

fn into_bytes<W: Write>(&self, writer: &mut W)

Writes the binary representation into writer.

impl<U: ColumnarUpdate> Default for RecordedUpdates<U>

fn default() -> Self

Returns the “default value” for a type.

impl<U: Update, H: for<'a> FnMut(Ref<'a, U::Key>) -> u64> Distributor<RecordedUpdates<U>> for ValDistributor<U, H>

fn partition<T: Clone, P: Push<Message<T, RecordedUpdates<U>>>>( &mut self, container: &mut RecordedUpdates<U>, time: &T, pushers: &mut [P], )

Partition the contents of container at time into the pushers.

fn flush<T: Clone, P: Push<Message<T, RecordedUpdates<U>>>>( &mut self, _time: &T, _pushers: &mut [P], )

Flush any remaining contents into the pushers at time time.

fn relax(&mut self)

Optionally release resources, such as memory.

impl<K, V, T1, T2, R> Enter<T1, T2> for RecordedUpdates<(K, V, T1, R)>

where (K, V, T1, R): Update<Key = K, Val = V, Time = T1, Diff = R>, (K, V, T2, R): Update<Key = K, Val = V, Time = T2, Diff = R>, T1: Timestamp + Columnar + Default + Clone, T2: Refines<T1> + Columnar + Default + Clone, K: Columnar, V: Columnar, R: Columnar,

type InnerContainer = RecordedUpdates<(K, V, T2, R)>

The resulting container type.

fn enter(self) -> Self::InnerContainer

Update timestamps from T1 to T2.

impl<K, V, T1, T2, R> Leave<T1, T2> for RecordedUpdates<(K, V, T1, R)>

where (K, V, T1, R): Update<Key = K, Val = V, Time = T1, Diff = R>, (K, V, T2, R): Update<Key = K, Val = V, Time = T2, Diff = R>, T1: Refines<T2> + Columnar + Default + Clone, T2: Timestamp + Columnar + Default + Clone, K: Columnar, V: Columnar, R: Columnar,

type OuterContainer = RecordedUpdates<(K, V, T2, R)>

The resulting container type.

fn leave(self) -> Self::OuterContainer

Update timestamps from T1 to T2.

impl<U: Update<Diff: Abelian>> Negate for RecordedUpdates<U>

fn negate(self) -> Self

Negates Abelian differences of each update.

impl<T, U, H> ParallelizationContract<T, RecordedUpdates<U>> for ValPact<H>

where T: Timestamp, U: Update, H: for<'a> FnMut(Ref<'a, U::Key>) -> u64 + 'static,

type Pusher = Exchange<T, LogPusher<Box<dyn Push<Message<T, RecordedUpdates<U>>>>>, ValDistributor<U, H>>

Type implementing Push produced by this pact.

type Puller = LogPuller<Box<dyn Pull<Message<T, RecordedUpdates<U>>>>>

Type implementing Pull produced by this pact.

fn connect( self, worker: &Worker, identifier: usize, address: Rc<[usize]>, logging: Option<TimelyLogger>, ) -> (Self::Pusher, Self::Puller)

Allocates a matched pair of push and pull endpoints implementing the pact.

impl<'a, U: ColumnarUpdate> PushInto<&'a mut RecordedUpdates<U>> for TrieChunker<U>

fn push_into(&mut self, container: &'a mut RecordedUpdates<U>)

Push item into self.

impl<U: Update> ResultsIn<<<U as ColumnarUpdate>::Time as Timestamp>::Summary> for RecordedUpdates<U>

fn results_in(self, step: &<U::Time as Timestamp>::Summary) -> Self

Advance times in the container by step.