Struct Delta0 

pub struct Delta0<D> { /* private fields */ }

delta_0 DBSP operator.

delta_0 is an import operator, i.e., an operator that makes the contents of a parent stream available inside the child circuit. At the first nested clock cycle, it reads and outputs a value from the parent stream. During subsequent nested clock cycles, it outputs zero.

Examples

Given a parent stream

[1, 2, 3, 4, ...]

the delta_0 operator produces the following nested stream (each row in the matrix represents a nested clock epoch):

┌           ┐
│1 0 0 0 ...│
│2 0 0 0 ...│
│3 0 0 0 ...|
|4 0 0 0 ...|
└           ┘

Implementations

impl<D> Delta0<D>

pub fn new() -> Self

Trait Implementations

impl<D> Default for Delta0<D>

fn default() -> Self

Returns the “default value” for a type.

impl<D> ImportOperator<D, D> for Delta0<D>

where D: HasZero + Clone + 'static,

fn input_preference(&self) -> OwnershipPreference

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

fn import(&mut self, val: &D)

Consumes a value from the parent stream by reference.

fn import_owned(&mut self, val: D)

Consumes a value from the parent stream by value.

async fn eval(&mut self) -> D

Invoked once per nested clock cycle to write a value to the output stream.

impl<D> Operator for Delta0<D>

where D: Data,

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

Human-readable operator name for debugging purposes.

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 metadata(&self, _meta: &mut OperatorMeta)

Collects metadata about the current operator

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