Struct TokioMonitor 

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

Asynchronous monitor built on Tokio synchronization primitives.

TokioMonitor protects one state value with a Tokio mutex and coordinates waiters with a Tokio notification primitive. Notification semantics follow Tokio’s Notify behavior.

Implementations

impl<T> TokioMonitor<T>

pub fn new(state: T) -> Self

Creates an asynchronous monitor protecting the supplied state.

Arguments

• state - Initial protected state.

Returns

A Tokio-based monitor.

pub async fn async_read<R, F>(&self, f: F) -> R

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

Acquires the monitor and reads the protected state.

Arguments

• f - Closure that receives an immutable reference to the state.

Returns

The value returned by the closure.

pub async fn async_write<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Acquires the monitor and mutates the protected state.

This does not notify waiters automatically.

Arguments

• f - Closure that receives a mutable reference to the state.

Returns

The value returned by the closure.

pub async fn async_write_notify_one<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Mutates the protected state and wakes one waiter.

Arguments

• f - Closure that receives a mutable reference to the state.

Returns

The value returned by the closure.

pub async fn async_write_notify_all<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Mutates the protected state and wakes all waiters.

Arguments

• f - Closure that receives a mutable reference to the state.

Returns

The value returned by the closure.

pub fn notify_one(&self)

Wakes one async waiter.

pub fn notify_all(&self)

Wakes all async waiters.

Trait Implementations

impl<T> AsRef<TokioMonitor<T>> for ArcTokioMonitor<T>

fn as_ref(&self) -> &TokioMonitor<T>

Returns a reference to the wrapped Tokio monitor.

impl<T: Send> AsyncConditionWaiter for TokioMonitor<T>

fn async_wait_until<'a, R, P, F>( &'a self, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, R>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits until the predicate becomes true.

fn async_wait_while<'a, R, P, F>( &'a self, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, R>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits while the predicate remains true.

type State = T

State protected by the monitor.

impl<T: Send> AsyncNotificationWaiter for TokioMonitor<T>

fn async_wait<'a>(&'a self) -> AsyncMonitorFuture<'a, ()>

Returns a future that resolves after a Tokio notification.

impl<T: Send> AsyncTimeoutConditionWaiter for TokioMonitor<T>

fn async_wait_until_for<'a, R, P, F>( &'a self, timeout: Duration, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, WaitTimeoutResult<R>>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits until the predicate becomes true or times out.

fn async_wait_while_for<'a, R, P, F>( &'a self, timeout: Duration, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, WaitTimeoutResult<R>>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits while the predicate remains true or times out.

impl<T: Send> AsyncTimeoutNotificationWaiter for TokioMonitor<T>

fn async_wait_for<'a>( &'a self, timeout: Duration, ) -> AsyncMonitorFuture<'a, WaitTimeoutStatus>

Returns a future that resolves after notification or timeout.

impl<T: Default> Default for TokioMonitor<T>

fn default() -> Self

Creates a Tokio monitor containing T::default().

impl<T> From<T> for TokioMonitor<T>

fn from(value: T) -> Self

Creates a Tokio monitor from an initial state value.

impl<T> Notifier for TokioMonitor<T>

fn notify_one(&self)

Wakes one async waiter.

fn notify_all(&self)

Wakes all async waiters.