Struct TransactionZ1 

pub struct TransactionZ1<T> { /* private fields */ }

Implementations

impl<T> TransactionZ1<T>

where T: Checkpoint + Clone,

pub fn new(zero: T) -> Self

Trait Implementations

impl<T> Operator for TransactionZ1<T>

where T: Checkpoint + SizeOf + NumEntries + Clone + 'static,

fn name(&self) -> Cow<'static, str>

Human-readable operator name for debugging purposes.

fn clock_start(&mut self, _scope: Scope)

Notify the operator about the start of a new clock epoch.

fn clock_end(&mut self, _scope: Scope)

fn init(&mut self, global_id: &GlobalNodeId)

Initialize the operator

fn fixedpoint(&self, scope: Scope) -> bool

Check if the operator is in a stable state.

fn checkpoint( &mut self, base: &StoragePath, persistent_id: Option<&str>, files: &mut Vec<Arc<dyn FileCommitter>>, ) -> Result<(), Error>

Instructs the operator to checkpoint its state to persistent storage in directory base. Any files that the operator creates should have persistent_id in their names to keep them unique.

fn restore( &mut self, base: &StoragePath, persistent_id: Option<&str>, ) -> Result<(), Error>

Instruct the operator to restore its state from persistent storage in directory base, using persistent_id to find its files.

fn clear_state(&mut self) -> Result<(), Error>

Clear the operator’s state.

fn flush(&mut self)

Notifies the operator that all of its predecessors have produced all outputs for the current transaction.

fn location(&self) -> OperatorLocation

The location the operator was created at

fn metadata(&self, _meta: &mut OperatorMeta)

Collects metadata about the current operator

fn is_async(&self) -> bool

Returns true if self is an asynchronous operator.

fn is_input(&self) -> bool

Returns true if self is an input operator.

fn ready(&self) -> bool

Returns true if self has received all required external inputs and is ready to run.

fn register_ready_callback<F>(&mut self, _cb: F)

where F: Fn() + Send + Sync + 'static,

Register callback to be invoked when an asynchronous operator becomes ready.

fn start_replay(&mut self) -> Result<(), Error>

Start replaying the operator’s state to the replay stream.

fn is_replay_complete(&self) -> bool

Check if the operator has finished replaying its state.

fn end_replay(&mut self) -> Result<(), Error>

Cleanup any state needed for replay and prepare the operator for normal operation.

fn start_transaction(&mut self)

Notify the operator about start of a transaction.

fn is_flush_complete(&self) -> bool

Invoked after flush after each eval call to check if all outputs have been produced. Because it is invoked only after calling eval, every operator must produce at least one output.

fn flush_progress(&self) -> Option<Position>

Returns the current progress of the operator in processing the current transaction.

fn start_compaction(&mut self)

Start compaction of the operator’s state.

impl<T> UnaryOperator<T, T> for TransactionZ1<T>

where T: Checkpoint + SizeOf + NumEntries + Clone + 'static,

async fn eval(&mut self, i: &T) -> T

Consume input by reference.

fn input_preference(&self) -> OwnershipPreference

Ownership preference on the operator’s input stream (see OwnershipPreference).

async fn eval_owned(&mut self, input: I) -> O

Consume input by value.