Struct SharedState 

pub struct SharedState { /* private fields */ }

A thread-safe, async, string→JSON store shared by all executors in a run.

Cheap to clone (an Arc handle); clones share the same underlying store. Guards against concurrent access with a tokio::sync::RwLock. See the module docs for the staged (pending/committed) superstep semantics.

Warning: keys beginning with _ are reserved for internal framework use.

Implementations

impl SharedState

pub fn new() -> SharedState

Create an empty shared state.

pub async fn get(&self, key: &str) -> Option<Value>

Get a value by key, if present. Checks the pending buffer first (so an executor observes its own writes) and then committed state.

pub async fn set(&self, key: impl Into<String>, value: impl Into<Value>)

Stage a value for key, overwriting any existing pending write. The value is visible to subsequent SharedState::get calls but is not folded into committed state until SharedState::commit.

pub async fn has(&self, key: &str) -> bool

Whether a key exists in pending (as a non-tombstone) or committed state.

pub async fn delete(&self, key: &str) -> bool

Stage a deletion of key, returning whether the key currently exists.

If the key exists only in the pending buffer it is removed there; if it exists in committed state a tombstone is staged so the key is removed at SharedState::commit.

pub async fn update<F>(&self, key: impl Into<String>, f: F)

where F: FnOnce(Option<Value>) -> Value,

Atomically read-modify-write a key under the write lock, staging the result into the pending buffer.

The closure receives the current value (pending-first, then committed) or None and returns the new value to stage. Rust analogue of Python’s hold/set_within_hold pattern for a single key.

pub async fn commit(&self)

Fold all pending writes into committed state and clear the buffer.

Called by the runner at each superstep boundary, after the superstep’s executors finish successfully and before checkpointing.

pub async fn discard(&self)

Discard all pending writes without committing them.

pub async fn export(&self) -> HashMap<String, Value>

Export a snapshot copy of the committed state (used for checkpointing). Pending writes are deliberately excluded.

pub async fn import(&self, state: HashMap<String, Value>)

Merge a serialized state map into committed state (used on restore).

pub async fn clear(&self)

Remove all entries, both committed and pending.

Trait Implementations

impl Clone for SharedState

fn clone(&self) -> SharedState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for SharedState

fn default() -> SharedState

Returns the “default value” for a type.