Struct Z1Nested 

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

z^-1 operator over streams of streams.

The operator stores a complete nested stream consumed at the last iteration of the parent clock and outputs it at the next parent clock cycle. It outputs a stream of zeros in the first parent clock tick.

One important subtlety is that mathematically speaking nested streams are infinite, but we can only compute and store finite prefixes of such streams. When asked to produce output beyond the stored prefix, the z^-1 operator repeats the last value in the stored prefix. The assumption here is that the circuit was evaluated to a fixed point at the previous parent timestamp, and hence the rest of the stream will contain the same fixed point value. This is not generally true for all circuits, and users should keep this in mind when instantiating the operator.

It is a strict operator.

Examples

Input (one row per parent timestamps):

1 2 3 4
1 1 1 1 1
2 2 2 0 0

Output:

0 0 0 0
1 2 3 4 4
1 1 1 1 1

Trait Implementations

impl<T> Operator for Z1Nested<T>

where T: Eq + 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 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 location(&self) -> OperatorLocation

The location the operator was created at

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

Initialize the 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 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 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.

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

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

impl<T> StrictOperator<T> for Z1Nested<T>

where T: Eq + 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 Z1Nested<T>

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

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 Z1Nested<T>

where T: Eq + 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).