Struct AwaitableState 

pub(crate) struct AwaitableState<T> {
    state: Arc<RwLock<T>>,
    notify: Arc<Notify>,
}

A concurrent state - one which allows reading, writing, and waiting for changes made by another concurrent writer.

This is morally similar to a mutex with a condvar, but allowing asynchronous waits and with access methods that make it a little trickier to accidentally hold a lock across a yield point.

Fields

state: Arc<RwLock<T>>

notify: Arc<Notify>

NB: we can’t wrap the Notify in the lock since the signature of Notify::notified doesn’t allow it, but this is only accessed while holding the lock.

Implementations

impl<T> AwaitableState<T>

pub fn new(value: T) -> Self

pub fn read<A>(&self, read_fn: impl FnOnce(&T) -> A) -> A

pub fn maybe_modify<A>( &self, write_fn: impl FnOnce(&mut ModifyGuard<'_, T>) -> A, ) -> A

Conditionally modify the state. This method passes a guard to the provided function, which only allows mutable access to the data via ModifyGuard::get_mut. If that method is not called, waiters will not be woken up.

pub fn modify<A>(&self, write_fn: impl FnOnce(&mut T) -> A) -> A

pub async fn wait_for<A>(&self, wait_fn: impl FnMut(&T) -> Option<A>) -> A

pub async fn wait_while(&self, wait_fn: impl FnMut(&T) -> bool)

Trait Implementations

impl<T> Clone for AwaitableState<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AwaitableState<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.