Struct CountedEvent 

pub struct CountedEvent<E> { /* private fields */ }

A CountedEvent wraps a type that implements the EventSetter trait. It can tell you how many waiters there are on that very event. The count will only go up once the waiter actually starts waiting on the event. If there is an immediate return on the first time the wait is polled, the count will not go up.

The count will go up if the first call to poll wait returns Poll::Pending, indicating that the waiter is actually waiting on notification. Upon notification, the count will be decremented.

Cancel Safety

On Drop the count is decremented if the CountedAwaiter had already incremented the count and is not yet in the complete state.

Implementations

impl<E> CountedEvent<E>

where for<'a> E: EventSetter<'a>,

pub fn new(source: E) -> Self

pub fn wait(&self) -> <Self as EventSetter<'_>>::Waiter

pub fn set_one(&self)

pub fn set_all(&self)

pub fn count(&self) -> usize

Trait Implementations

impl<'a, E> EventSetter<'a> for CountedEvent<E>

where E: EventSetter<'a> + 'a,

type Waiter = CountedAwaiter<'a, E, <E as EventSetter<'a>>::Waiter>

The future representing a pending acquisition of the event.

fn new() -> Self

Creates a new event in the unset state. This is the expected mode of operation for most events, and means that if a task begins waiting, they will wait until the event is set.

fn new_set() -> Self

Creates an event in the set state. This means that the event can be immediately acquired.

fn wait(&'a self) -> CountedAwaiter<'a, E, E::Waiter>

Waits on the event. This returns a future which when polled will wait for the event to be acquired.

fn try_wait(&self) -> bool

Will try to immediately acquire the event along the fast path. This method is non-blocking and will return true if we could acquire the event, and false if we cannot. This will clear the set flag.

fn set_all<F: FnMut()>(&self, functor: F)

Sets the event and wakes up all events from the queue if they are pending with the functor. This functor allows more advanced book-keeping per event, for instance with counted events.

fn set_one(&self) -> bool

Sets the event. This will wake up any events from the queue if any are pending. This returns a boolean if we were able to actually wake up an event or not.

fn has_waiters(&self) -> bool

If the event has any pending waiters.