Struct base::wait_context::WaitContext

pub struct WaitContext<T: EventToken>(pub(crate) EventContext<T>);

Used to wait for multiple objects which are eligible for waiting.

Example

use base::{Event, EventToken, Result, WaitContext};

#[derive(EventToken, Copy, Clone, Debug, PartialEq, Eq)]
enum ExampleToken {
   SomeEvent(u32),
   AnotherEvent,
}

let evt1 = Event::new()?;
let evt2 = Event::new()?;
let another_evt = Event::new()?;

let ctx: WaitContext<ExampleToken> = WaitContext::build_with(&[
    (&evt1, ExampleToken::SomeEvent(1)),
    (&evt2, ExampleToken::SomeEvent(2)),
    (&another_evt, ExampleToken::AnotherEvent),
])?;

// Trigger one of the `SomeEvent` events.
evt2.signal()?;

// Wait for an event to fire. `wait()` will return immediately in this example because `evt2`
// has already been triggered, but in normal use, `wait()` will block until at least one event
// is signaled by another thread or process.
let events = ctx.wait()?;
let tokens: Vec<ExampleToken> = events.iter().filter(|e| e.is_readable)
    .map(|e| e.token).collect();
assert_eq!(tokens, [ExampleToken::SomeEvent(2)]);

// Reset evt2 so it doesn't trigger again in the next `wait()` call.
let _ = evt2.reset()?;

// Trigger a different event.
another_evt.signal()?;

let events = ctx.wait()?;
let tokens: Vec<ExampleToken> = events.iter().filter(|e| e.is_readable)
    .map(|e| e.token).collect();
assert_eq!(tokens, [ExampleToken::AnotherEvent]);

let _ = another_evt.reset()?;

Tuple Fields

0: EventContext<T>

Implementations

impl<T: EventToken> WaitContext<T>

pub fn new() -> Result<WaitContext<T>>

Creates a new WaitContext.

pub fn build_with(
    triggers: &[(&dyn AsRawDescriptor, T)]
) -> Result<WaitContext<T>>

Creates a new WaitContext with the the associated triggers.

pub fn add(&self, descriptor: &dyn AsRawDescriptor, token: T) -> Result<()>

Adds a trigger to the WaitContext.

pub fn add_for_event(
    &self,
    descriptor: &dyn AsRawDescriptor,
    event_type: EventType,
    token: T
) -> Result<()>

Adds a trigger to the WaitContext watching for a specific type of event

pub fn add_many(&self, triggers: &[(&dyn AsRawDescriptor, T)]) -> Result<()>

Adds multiple triggers to the WaitContext.

pub fn modify(
    &self,
    descriptor: &dyn AsRawDescriptor,
    event_type: EventType,
    token: T
) -> Result<()>

Modifies a trigger already added to the WaitContext. If the descriptor is already registered, its associated token will be updated.

pub fn delete(&self, descriptor: &dyn AsRawDescriptor) -> Result<()>

Removes the given handle from triggers registered in the WaitContext if present.

pub fn wait(&self) -> Result<SmallVec<[TriggeredEvent<T>; 16]>>

Waits for one or more of the registered triggers to become signaled.

pub fn wait_timeout(
    &self,
    timeout: Duration
) -> Result<SmallVec<[TriggeredEvent<T>; 16]>>

Waits for one or more of the registered triggers to become signaled, failing if no triggers are signaled before the designated timeout has elapsed.

Trait Implementations

impl<T: EventToken> AsRawDescriptor for WaitContext<T>

fn as_raw_descriptor(&self) -> RawDescriptor

Returns the underlying raw descriptor.