Struct differential_dataflow::trace::wrappers::freeze::TraceFreeze

pub struct TraceFreeze<Tr, F>
where
    Tr: TraceReader,
    F: Fn(Tr::TimeGat<'_>) -> Option<Tr::Time>,
{ /* private fields */ }

Wrapper to provide trace to nested scope.

Implementations

impl<Tr, F> TraceFreeze<Tr, F>

where Tr: TraceReader, Tr::Batch: Clone, F: Fn(Tr::TimeGat<'_>) -> Option<Tr::Time>,

pub fn make_from(trace: Tr, func: Rc<F>) -> Self

Makes a new trace wrapper

Trait Implementations

impl<Tr, F> Clone for TraceFreeze<Tr, F>

where Tr: TraceReader + Clone, F: Fn(Tr::TimeGat<'_>) -> Option<Tr::Time>,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tr, F> TraceReader for TraceFreeze<Tr, F>

where Tr: TraceReader, Tr::Batch: Clone, F: Fn(Tr::TimeGat<'_>) -> Option<Tr::Time> + 'static,

type Key<'a> = <Tr as TraceReader>::Key<'a>

Key by which updates are indexed.

type Val<'a> = <Tr as TraceReader>::Val<'a>

Values associated with keys.

type Time = <Tr as TraceReader>::Time

Timestamps associated with updates

type TimeGat<'a> = <Tr as TraceReader>::TimeGat<'a>

Borrowed form of timestamp.

type Diff = <Tr as TraceReader>::Diff

Owned form of update difference.

type DiffGat<'a> = <Tr as TraceReader>::DiffGat<'a>

Borrowed form of update difference.

type Batch = BatchFreeze<<Tr as TraceReader>::Batch, F>

The type of an immutable collection of updates.

type Storage = <Tr as TraceReader>::Storage

Storage type for Self::Cursor. Likely related to Self::Batch.

type Cursor = CursorFreeze<<Tr as TraceReader>::Cursor, F>

The type used to enumerate the collections contents.

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

Maps logic across the non-empty sequence of batches in the trace.

fn set_logical_compaction(&mut self, frontier: AntichainRef<'_, Tr::Time>)

Advances the frontier that constrains logical compaction.

fn get_logical_compaction(&mut self) -> AntichainRef<'_, Tr::Time>

Reports the logical compaction frontier.

fn set_physical_compaction(&mut self, frontier: AntichainRef<'_, Tr::Time>)

Advances the frontier that constrains physical compaction.

fn get_physical_compaction(&mut self) -> AntichainRef<'_, Tr::Time>

Reports the physical compaction frontier.

fn cursor_through( &mut self, upper: AntichainRef<'_, Tr::Time>, ) -> Option<(Self::Cursor, Self::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 cursor(&mut self) -> (Self::Cursor, Self::Storage)

Provides a cursor over updates contained in the trace.

fn advance_by(&mut self, frontier: AntichainRef<'_, Self::Time>)

👎Deprecated since 0.11: please use set_logical_compaction

Deprecated form of set_logical_compaction.

fn advance_frontier(&mut self) -> AntichainRef<'_, Self::Time>

👎Deprecated since 0.11: please use get_logical_compaction

Deprecated form of get_logical_compaction.

fn distinguish_since(&mut self, frontier: AntichainRef<'_, Self::Time>)

👎Deprecated since 0.11: please use set_physical_compaction

Deprecated form of set_physical_compaction.

fn distinguish_frontier(&mut self) -> AntichainRef<'_, Self::Time>

👎Deprecated since 0.11: please use get_physical_compaction

Deprecated form of get_physical_compaction.

fn read_upper(&mut self, target: &mut Antichain<Self::Time>)

Reads the upper frontier of committed times.

fn advance_upper(&mut self, upper: &mut Antichain<Self::Time>)

Advances upper by any empty batches.