Struct task_notify::Notify

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

A wrapper which wakes tasks on mutable accesses to the wrapped value.

This can be used to transparently notify an asyncronous task that it should, for example, check for more work in a queue or try again to acquire a lock.

Importantly: only DerefMut is used to wake the target task. Read-only access is possible without causing wake events. If no Waker has been registered yet, no task will be woken.

Implementations

impl<T> Notify<T>

pub fn new(inner: T) -> Self

pub fn has_waker(ptr: &Notify<T>) -> bool

Check whether or not this Notify has a registered Waker.

This function is implemented as an associated function rather than a method to avoid conflicts with methods on the wrapped type. Call it as Notify::has_waker().

pub fn waker(ptr: &mut Notify<T>) -> Option<Waker>

Get a copy of the registered Waker for this Notify.

This function is implemented as an associated function rather than a method to avoid conflicts with methods on the wrapped type. Call it as Notify::waker().

pub fn wake(ptr: &mut Notify<T>)

Call wake on the waker, if it’s a waker, yehaa!

pub fn register_waker(ptr: &mut Notify<T>, waker: &Waker)

Register a Waker to be woken upon mutable accesses to the wrapped value.

This function is implemented as an associated function rather than a method to avoid conflicts with methods on the wrapped type. Call it as Notify::register_waker().

Panics

Panics if there is an already registered Waker. Use Notify::has_waker to check the state before using this.

pub fn clear_waker(ptr: &mut Notify<T>) -> Option<Waker>

Removes and returns the Waker registered to this Notify.

This function is implemented as an associated function rather than a method to avoid conflicts with methods on the wrapped type. Call it as Notify::clear_waker().

pub fn into_inner(ptr: Notify<T>) -> T

Consumes the Notify, dropping any associated Waker and returning the inner value without notifying the Waker.

This function is implemented as an associated function rather than a method to avoid conflicts with methods on the wrapped type. Call it as Notify::into_inner().

Trait Implementations

impl<T: Clone> Clone for Notify<T>

fn clone(&self) -> Notify<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Notify<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Notify<T>

fn default() -> Notify<T>

Returns the “default value” for a type.

impl<T> Deref for Notify<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Notify<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.