Struct Slock

pub struct Slock<T> { /* private fields */ }

The Slock object.

An atomically reference counted read/write lock with special safety features to avoid deadlocks.

When used correctly (no nesting lock access functions), deadlocks should be impossible.

Implementations

impl<T> Slock<T>

pub fn new(value: T) -> Self

Create a new Slock with a given initial value.

pub async fn map<F, U>(&self, mapper: F) -> Result<U, Elapsed>

where F: FnOnce(&T) -> U,

Extract inner values from within a Slock

let name = lock.map(|v| v.name).await;

pub async fn set<F>(&self, setter: F)

where F: FnOnce(T) -> T,

A setter for changing the internal data of the lock.

let lock = Slock::new(1i32);

lock.set(|v| v + 1).await;
lock.set(|_| 6).await;

pub fn split(&self) -> Self

👎Deprecated: Use clone() instead

Create’s a new lock pointing to the same data. Modifying the data in the new lock will result in seeing the same change in the old lock.

let lock = Slock::new(0i32);
let the_same_lock = lock.split();

pub async fn hook<F>(&self, hook: F)

where F: FnMut(&T) + 'static,

Subscribe to changes in the lock.

hook will be called any time Slock::set is called.

impl<T: Clone> Slock<T>

pub async fn get_clone(&self) -> T

Returns a clone of the lock’s data.

pub async fn clone_deep(&self) -> Self

Create a new lock with data clone from this one.

impl<T> Slock<Vec<T>>

pub async fn push(&self, value: T)

Asyncronously push to a vec. Note that due to the nature of async code, order cannot be guaranteed.

impl<T> Slock<Slock<T>>

pub async fn flatten(&self) -> Slock<T>

Converts from Slock<Slock<T>> to Slock<T>

impl<K: Eq + Hash + Copy, V> Slock<HashMap<K, Slock<V>>>

pub fn new_map() -> Slock<HashMap<K, Slock<V>>>

Create a new Slock powered HashMap

pub async fn insert<F>(&self, key: K, setter: F)

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

Insert / modify a value in the map at a given key.

pub async fn from_key(&self, key: K) -> Option<Slock<V>>

Get a value from the map at a given key.

impl<T: Copy> Slock<T>

pub async fn get(&self) -> T

If a lock’s data implements copy, this will return an owned copy of it.

Trait Implementations

impl<T> Clone for Slock<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Send> Send for Slock<T>

impl<T: Send> Sync for Slock<T>