Struct Signal 

pub struct Signal<S, M = NoopRawMutex> { /* private fields */ }

Signal is an async synchonization primitive that can be viewed as a generalization of the embassy_sync::Signal primitive that takes callback closures.

It allows for waiting on a condition of its state S to become true, where whether the condition is met is decided by a callback closure.

It also allows for modifying the state S and waking up the waiters - but only as long as a callback closure provides information that the state is modified in such a way, that the waiters should be notified.

The generic nature of Signal allows for a wide range of use cases, including the implementation of:

• the Notification primitive
• the IfMutex primitive

Implementations

impl<S, M> Signal<S, M>

where M: RawMutex,

pub const fn new(state: S) -> Signal<S, M>

Create a Signal with the given initial state S.

pub fn init<I>(state: I) -> impl Init<Signal<S, M>>

where I: Init<S>,

Create a Signal in-place initializer with the given initial state initializer I.

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

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

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

where F: FnMut(&mut S) -> Option<R>,

pub fn poll_wait<F, R>(&self, ctx: &mut Context<'_>, f: F) -> Poll<R>

where F: FnOnce(&mut S) -> Option<R>,

impl<T, M> Signal<Option<T>, M>

where M: RawMutex,

pub fn signal(&self, value: T)

Notify the waiter.

pub async fn wait_signalled(&self) -> T

Wait for the notification.