Struct popol::Waker

pub struct Waker { /* fields omitted */ }

Wakers are used to wake up wait.

Implementations

impl Waker

pub fn new<K: Eq + Clone>(sources: &mut Sources<K>, key: K) -> Result<Waker>

Create a new Waker.

Examples

Wake a wait call from another thread.

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::thread;
    use std::time::Duration;
    use std::sync::Arc;

    use popol::{Sources, Events, Waker};

    const WAKER: &'static str = "waker";

    let mut events = Events::new();
    let mut sources = Sources::new();

    // Create a waker and keep it alive until the end of the program, so that
    // the reading end doesn't get closed.
    let waker = Arc::new(Waker::new(&mut sources, WAKER)?);
    let _waker = waker.clone();

    let handle = thread::spawn(move || {
        thread::sleep(Duration::from_millis(160));

        // Wake up popol on the main thread.
        _waker.wake().expect("waking shouldn't fail");
    });

    // Wait to be woken up by the other thread. Otherwise, time out.
    sources.wait_timeout(&mut events, Duration::from_secs(1))?;

    assert!(!events.is_empty(), "There should be at least one event selected");

    let mut events = events.iter();
    let (key, event) = events.next().unwrap();

    assert!(key == &WAKER, "The event is triggered by the waker");
    assert!(event.readable, "The event is readable");
    assert!(events.next().is_none(), "There was only one event");

    handle.join().unwrap();

    Ok(())
}

pub fn wake(&self) -> Result<()>

Wake up a waker. Causes popol::wait to return with a readiness event for this waker.