Struct popol::Waker

pub struct Waker { /* private fields */ }

Wakers are used to wake up wait.

Implementations

impl Waker

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

Create a new Waker and register it.

Examples

Wake a poll 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::{Event, Sources, Waker, Timeout};

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

    let mut events = Vec::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::register(&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.poll(&mut events, Timeout::from_secs(1))?;

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

    let mut events = events.iter();
    let Event { key, source } = events.next().unwrap();

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

    handle.join().unwrap();

    Ok(())
}

pub fn new() -> Result<Waker>

Create a new waker.

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

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

pub fn reset(fd: impl AsRawFd) -> Result<()>

Reset the waker by draining the receive buffer.

Trait Implementations

impl AsRawFd for &Waker

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.