Struct ConcurrentSharedData 

pub struct ConcurrentSharedData { /* private fields */ }

Implementation that handles updates of the given key-value taking into account that race conditions could arise between reading and writing values to the shared memory.

Implementations

impl ConcurrentSharedData

pub fn new(clock: Rc<dyn Clock>, shared_data: Rc<dyn SharedData>) -> Self

Create a new instance.

pub fn insert<T, F>( &self, key: String, data: T, handle_consistency: F, ) -> (TransactionStatus, T)

where T: Clone + Serialize + DeserializeOwned, F: Fn(T, T) -> Option<T>,

Insert an element, if the element has a different value from the last time it was read, then the function will be invoked to resolve the conflict.

pub fn update<T, F>( &self, key: &str, update_function: F, ) -> (TransactionStatus, Option<T>)

where T: Clone + Serialize + DeserializeOwned, F: Fn(Option<&T>) -> Result<Option<T>, UpdateError>,

Updates an element, if the element has a different value from the last time it was read, then the function will be invoked to resolve the conflict.

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

where T: Clone + Serialize + DeserializeOwned,

Get an element for the given key.

pub fn remove<T>(&self, key: &str) -> Option<T>

where T: Clone + Serialize + DeserializeOwned,

Removes the element for the given key.

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

Get list of keys currently stored.

pub fn safe_remove(&self, key: &str)

Remove the element for the given key. This function fails silently.

Trait Implementations

impl<C> FromContext<C> for ConcurrentSharedData

where Rc<dyn Clock>: FromContext<C, Error = Infallible>, Rc<dyn SharedData>: FromContext<C, Error = Infallible>,

type Error = Infallible

fn from_context(context: &C) -> Result<Self, Self::Error>

fn from_context_always(context: &C) -> Self

where Self: FromContext<C, E, Error = Infallible>,