Struct SharedStateManager 

pub struct SharedStateManager { /* private fields */ }

Shared State Manager for inter-agent state sharing

Implementations

impl SharedStateManager

pub fn new() -> Self

Create a new shared state manager

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

Get a value by key

pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Option<T>

Get a typed value by key

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

Set a value by key

pub fn set_typed<T: Serialize>( &mut self, key: impl Into<String>, value: &T, ) -> SharedStateResult<()>

Set a typed value by key

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

Delete a value by key

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

Check if a key exists

pub fn keys(&self) -> Vec<String>

Get all keys

pub fn clear(&mut self)

Clear all state

pub fn watch<F>(&mut self, key: impl Into<String>, callback: F) -> WatchHandle

where F: Fn(Option<Value>) + Send + Sync + 'static,

Watch for changes to a key

pub fn unwatch(&mut self, handle: &WatchHandle) -> bool

Unwatch a key

pub fn on_event<F>(&mut self, listener: F)

where F: Fn(StateEvent) + Send + Sync + 'static,

Add an event listener

pub fn lock( &mut self, key: impl Into<String>, holder: impl Into<String>, timeout: Option<Duration>, ) -> SharedStateResult<Lock>

Acquire a lock on a key

If the key is already locked, this will wait until the lock is released or the timeout expires.

pub fn try_lock( &mut self, key: impl Into<String>, holder: impl Into<String>, timeout: Option<Duration>, ) -> Option<Lock>

Try to acquire a lock without waiting

pub fn prepare_lock( &mut self, key: impl Into<String>, holder: impl Into<String>, timeout: Option<Duration>, ) -> Result<(String, Receiver<Lock>), Lock>

Prepare an async lock request

Returns a receiver that will receive the lock when it becomes available. The caller should await on the receiver with a timeout.

pub fn unlock(&mut self, lock: &Lock) -> SharedStateResult<()>

Release a lock

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

Check if a key is locked

pub fn get_all_locks(&self) -> Vec<Lock>

Get all active locks

pub fn get_lock(&self, key: &str) -> Option<&Lock>

Get lock for a specific key

pub fn compare_and_swap( &mut self, key: &str, expected: &Value, new_value: Value, ) -> bool

Atomic compare-and-swap operation

Sets the value only if the current value equals the expected value. Returns true if the swap was successful.

pub fn compare_and_swap_typed<T: Serialize + PartialEq + for<'de> Deserialize<'de>>( &mut self, key: &str, expected: &T, new_value: &T, ) -> SharedStateResult<bool>

Atomic compare-and-swap with typed values

pub fn increment(&mut self, key: &str, delta: i64) -> i64

Atomic increment operation

Increments the value by delta. If the key doesn’t exist, initializes to delta. Returns the new value.

pub fn decrement(&mut self, key: &str, delta: i64) -> i64

Atomic decrement operation

pub fn cleanup_expired_locks(&mut self) -> usize

Cleanup expired locks

Returns the number of locks cleaned up.

pub fn get_stats(&self) -> SharedStateStats

Get statistics about the shared state

Trait Implementations

impl Default for SharedStateManager

fn default() -> SharedStateManager

Returns the “default value” for a type.