Struct Z1 

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

z^-1 operator delays its input by one timestamp.

The operator outputs a user-defined “zero” value in the first timestamp after clock_start. For all subsequent timestamps, it outputs the value received as input at the previous timestamp. The zero value is typically the neutral element of a monoid (e.g., 0 for addition or 1 for multiplication).

It is a strict operator.

Examples

time | input | output
---------------------
  0  |   5   |   0
  1  |   6   |   5
  2  |   7   |   6
  3  |   8   |   7
        ...

Implementations

impl<T> Z1<T>

where T: Checkpoint + Clone,

pub fn new(zero: T) -> Self

Trait Implementations

impl<T> Operator for Z1<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 metadata(&self, meta: &mut OperatorMeta)

Collects metadata about the current 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 location(&self) -> OperatorLocation

The location the operator was created at

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 flush(&mut self)

Notifies the operator that all of its predecessors have produced all outputs for the current 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> StrictOperator<T> for Z1<T>

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

fn get_output(&mut self) -> T

Returns the output value computed based on data consumed by the operator during previous timestamps. This method is invoked before eval_strict() has been invoked for the current timestamp. It can be invoked at most once for each timestamp, as the implementation may mutate or destroy the operator’s internal state (for example Z1 returns its inner value, leaving the operator empty).

fn get_final_output(&mut self) -> T

impl<T> StrictUnaryOperator<T, T> for Z1<T>

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

fn flush_input(&mut self)

Flush the input half of the strict operator.

fn is_flush_input_complete(&self) -> bool

See StrictUnaryOperator::flush_input for more details.

async fn eval_strict(&mut self, i: &T)

Feed input for the current timestamp to the operator by reference. The output will be consumed via get_output during the next timestamp.

async fn eval_strict_owned(&mut self, i: T)

Feed input for the current timestamp to the operator by value. The output will be consumed via get_output during the next timestamp.

fn input_preference(&self) -> OwnershipPreference

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

impl<T> UnaryOperator<T, T> for Z1<T>

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

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

Consume input by reference.

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

Consume input by value.

fn input_preference(&self) -> OwnershipPreference

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