Struct LockedExclusive 

pub struct LockedExclusive<'wait_list, L: Lock, I, O> {
    pub guard: <L as Lifetime<'wait_list>>::ExclusiveGuard,
    /* private fields */
}

An exclusive lock on a WaitList, created by WaitList::lock_exclusive.

Fields

guard: <L as Lifetime<'wait_list>>::ExclusiveGuard

The lock guard holding the lock on the WaitList.

You can use this field to access whatever auxiliary locked state you have associated with the WaitList.

Implementations

impl<'wait_list, L: Lock, I, O> LockedExclusive<'wait_list, L, I, O>

pub fn head_input_mut(&mut self) -> Option<&mut I>

Retrieve a unique reference to the input given by the head entry in the list, if there is one.

pub fn init_and_wait<OnCancel>( self, input: I, on_cancel: OnCancel, ) -> InitAndWait<'wait_list, L, I, O, OnCancel>

where OnCancel: CancelCallback<'wait_list, L, I, O>,

Wait on the list for someone to call Self::wake_one.

This method takes ownership of self so that the lock can be released while the future is suspended. At the end, ownership of the lock guard is transferred back to the caller.

A callback must be supplied to call in the event that the future has been woken but was cancelled before it could complete. You will often want to re-call Self::wake_one in this case to pass on the notification to someone else.

Note that the returned future will not be Send if your guard types are !Send. To avoid this problem, use the lower-level Wait API instead.

pub fn pop(&mut self, output: O) -> Result<(I, Waker), O>

Pop the first waiter from the front of the queue, if there is one.

Returns ownership of that waiter’s input value and the waker that can be used to wake it.

It is recommended to only wake the waker when the lock guard is not held, because waking the waker may attempt to drop the future (if for example the runtime is shutting down) which would deadlock if the future is registered in WaitList.

Errors

Returns an error and gives back the given output when there are no wakers in the list.

pub fn wake_one(self, output: O) -> Result<I, O>

Wake and dequeue the first waiter in the queue, if there is one.

Returns ownership of that waiter’s input value.

This method consumes self so we can ensure that the lock guard is freed before calling wake on the waker, to prevent deadlocks.

Errors

Returns an error and gives back the given output when there are no wakers in the list.

Methods from Deref<Target = LockedCommon<'wait_list, L, I, O>>

pub fn is_empty(&self) -> bool

Check whether there are any futures waiting in this list.

pub fn head_input(&self) -> Option<&I>

Retrieve a shared reference to the input given by the head entry in the list, if there is one.

Trait Implementations

impl<'wait_list, L: Lock + Debug, I, O> Debug for LockedExclusive<'wait_list, L, I, O>

where <L as Lifetime<'wait_list>>::ExclusiveGuard: Debug,

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

Formats the value using the given formatter.

impl<'wait_list, L: Lock, I, O> Deref for LockedExclusive<'wait_list, L, I, O>

type Target = LockedCommon<'wait_list, L, I, O>

The resulting type after dereferencing.

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

Dereferences the value.