Struct Engine 

pub struct Engine { /* private fields */ }

A live, incremental evaluation handle over a fixed model structure.

Implementations

impl Engine

pub fn new( model: &Model, targets: &[MeasureId], ) -> Result<(Engine, Snapshot), EngineError>

Build a live engine for model, tracking targets (derived measures). Seeds the graph with the model’s current input cells and returns a handle plus the initial snapshot.

pub fn set( &mut self, measure: MeasureId, coord: CoordKey, value: f64, ) -> Result<Snapshot, EngineError>

Set an input cell to value and return the recomputed snapshot of all tracked derived measures. Incremental: only affected coordinates flow.

pub fn clear( &mut self, measure: MeasureId, coord: CoordKey, ) -> Result<Snapshot, EngineError>

Remove an input cell and return the recomputed snapshot.

pub fn apply(&mut self, edits: Vec<Edit>) -> Result<Snapshot, EngineError>

Apply a batch of edits atomically (one time step) and return the new snapshot of all tracked derived measures. An edit’s coordinate may list its categories in any order: it is sorted into the engine’s key form, which the key kernels (improv_verified::keys) require.

pub fn targets(&self) -> &[MeasureId]

The derived measures this engine tracks.

pub fn serves(&self, model: &Model) -> Result<bool, EngineError>

Whether this engine computes model as a new engine would, so a model that differs from the one it was built on only in input cells and in new items can be fed to it as edits. False when a plan reads the item list of a category that gained items: POSITION, @ITEM, @ITEMCOUNT, PREV/NEXT, recurrences, windows, per-item and INTO reductions, FILL (its grid), RELABEL/SWAP (their item maps), and every reduction other than SUM … XOR, COUNT, COUNTA and COUNTUNIQUE (which read only their rows’ values: a new item reaches them as data, sorted last as an unknown item sorts). New items must have ids above every item of their category and come after them in its item order (append-only minting does both).

Trait Implementations

impl Drop for Engine

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.