Struct TransactionGenerator 

pub struct TransactionGenerator<T, F> { /* private fields */ }

A version of Generator that passes a flag to the generator function when flush has been called, giving it a chance to produce one output per transaction.

Implementations

impl<T, F> TransactionGenerator<T, F>

pub fn new(g: F) -> Self

Creates a generator

Trait Implementations

impl<T, F> Operator for TransactionGenerator<T, F>

where T: 'static, F: 'static,

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

Human-readable operator name for debugging purposes.

fn flush(&mut self)

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

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

Check if the operator is in a stable state.

fn is_input(&self) -> bool

Returns true if self is an input operator.

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

fn is_compaction_complete(&self) -> bool

Returns true when the operator’s background compaction has fully converged. Operators without a trace always return true.

impl<T, F> SourceOperator<T> for TransactionGenerator<T, F>

where F: FnMut(bool) -> T + 'static, T: 'static,

async fn eval(&mut self) -> T

Yield the next value.