Struct sync42::wait_list::WaitGuard

pub struct WaitGuard<'a, T: Clone + 'a> { /* private fields */ }

Callers link a Waiter into the list and protect it with a WaitGuard. The WaitGuard will panic if the caller fails to unlink.

Implementations

impl<'a, T: Clone + 'a> WaitGuard<'a, T>

pub fn iter<'b: 'a>(&'b self) -> WaitIterator<'b, T>

Iterate the list from our position forward.

pub fn index(&mut self) -> u64

Return our index into the list.

pub fn store(&mut self, t: T)

Store a value for the WaitGuard thread to load later.

pub fn load(&mut self) -> T

Load the value for the WaitGuard.

pub fn swap(&mut self, t: &mut T)

Swap with the current value.

pub fn is_head(&mut self) -> bool

True iff the thread is the lowest-index thread in the system.

pub fn count(&mut self) -> u64

Count how many threads are in the list. This should be used for debugging, not for logic.

pub fn get_waiter<'c, 'b: 'c>( &'b mut self, index: u64 ) -> Option<WaitGuard<'c, T>>

Use the WaitGuard provided by self to get a wait guard to a later position in the list. It is not possible to get a wait guard to an index less than our own position. This limitation enables us to enforce lifetimes with the borrow checker. Returns None if the owner called unlink on the index.

pub fn naked_wait<'b, M>(&self, guard: MutexGuard<'b, M>) -> MutexGuard<'b, M>

Atomically unlock the guard and wait on the internal condition variable.

pub fn wait_for_store<'b, M>( &self, guard: MutexGuard<'b, M> ) -> (MutexGuard<'b, M>, T)

Wait until someone stores a value in the guard. Note that you must always make sure that some other thread will call store on this wait guard’s index.

pub fn notify(&self)

Notify the waiter that it’s time to wake up.

Trait Implementations

impl<'a, T: Debug + Clone + 'a> Debug for WaitGuard<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Clone + 'a> Drop for WaitGuard<'a, T>

fn drop(&mut self)

Executes the destructor for this type.