Struct tokio::sync::notify::Waiter

struct Waiter {
    pointers: Pointers<Waiter>,
    waker: UnsafeCell<Option<Waker>>,
    notification: AtomicNotification,
    _p: PhantomPinned,
}

Fields

pointers: Pointers<Waiter>

Intrusive linked-list pointers.

waker: UnsafeCell<Option<Waker>>

Waiting task’s waker. Depending on the value of notification, this field is either protected by the waiters lock in Notify, or it is exclusively owned by the enclosing Waiter.

notification: AtomicNotification

Notification for this waiter. Uses 2 bits to store if and how was notified, 1 bit for storing if it was woken up using FIFO or LIFO, and the rest of it is unused.

• if it’s None, then waker is protected by the waiters lock.
• if it’s Some, then waker is exclusively owned by the enclosing Waiter and can be accessed without locking.

_p: PhantomPinned

Should not be Unpin.

Implementations

impl Waiter

fn new() -> Waiter

impl Waiter

unsafe fn addr_of_pointers(me: NonNull<Self>) -> NonNull<Pointers<Waiter>>

Trait Implementations

impl Debug for Waiter

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

Formats the value using the given formatter.

impl Link for Waiter

Safety

Waiter is forced to be !Unpin.

type Handle = NonNull<Waiter>

Handle to the list entry.

type Target = Waiter

Node type.

fn as_raw(handle: &NonNull<Waiter>) -> NonNull<Waiter>

Convert the handle to a raw pointer without consuming the handle.

unsafe fn from_raw(ptr: NonNull<Waiter>) -> NonNull<Waiter>

Convert the raw pointer to a handle

unsafe fn pointers(target: NonNull<Waiter>) -> NonNull<Pointers<Waiter>>

Return the pointers for a node