async_compatibility_layer::async_primitives::subscribable_mutex

Struct SubscribableMutex

pub struct SubscribableMutex<T: ?Sized> { /* private fields */ }

Expand description

A mutex that can register subscribers to be notified. This works in the same way as Mutex, but has some additional functions:

Self::subscribe will return a [Receiver] which can be used to be notified of changes.

Self::notify_change_subscribers will notify all Receiver that are registered with the subscribe function.

Implementations§

Source §

impl<T> SubscribableMutex<T>

Source

pub fn new(t: T) -> Self

Create a new mutex with the value T

Source

pub async fn lock(&self) -> MutexGuard<'_, T>

👎Deprecated: Consider using a different function instead

Acquires the mutex.

Returns a guard that releases the mutex when dropped.

Direct usage of this function may result in unintentional deadlocks. Consider using one of the following functions instead:

modify to edit the inner value.
set to set the inner value.
compare_and_set compare the inner value with a given value, and if they match, update the value to the second value.
copied and cloned gets a copy or clone of the inner value

Source

pub async fn notify_change_subscribers(&self)

Notify the subscribers that a change has occured. Subscribers can be registered by calling Self::subscribe.

Subscribers cannot be removed as they have no unique identifying information. Instead this function will simply remove all senders that fail to deliver their message.

Create a [Receiver] that will be notified every time a thread calls Self::notify_change_subscribers

Source

pub async fn modify<F>(&self, cb: F)
where F: FnOnce(&mut T),

Modify the internal value, then notify all subscribers that the value is updated.

Source

pub async fn set(&self, val: T)

Set the new inner value, discarding the old ones. This will also notify all subscribers.

Source

pub async fn wait_until<F>(&self, f: F)
where F: FnMut(&T) -> bool,

Wait until condition returns true. Will block until then.

Source

pub fn wait_until_with_trigger<'a, F>( &'a self, f: F, ) -> FuturesOrdered<impl Future<Output = ()> + 'a>
where F: FnMut(&T) -> bool + 'a,

Wait until f returns true. Turns a stream with two ordered events. The first event indicates that the stream is now listening for the state change, and the second event indicates that f has become true

Source

pub fn wait_timeout_until_with_trigger<'a, F>( &'a self, timeout: Duration, f: F, ) -> Timeout<FuturesOrdered<impl Future<Output = ()> + 'a>>
where F: FnMut(&T) -> bool + 'a,

Same functionality as Self::wait_until_with_trigger, except with timeout timeout on both events in stream

Source

pub async fn wait_timeout_until<F>(&self, timeout: Duration, f: F) -> Result<()>
where F: FnMut(&T) -> bool,

Wait timeout until f returns true. Will return Ok(()) if the function returned true before the time elapsed. Notifies caller over ready_chan when has begun to listen for changes to the internal state (locked within the Mutex)