Enum popol::Timeout

pub enum Timeout {
    After(Duration),
    Never,
}

Optional timeout.

Note that the maximum timeout is i32::MAX milliseconds (about 25 days). Longer timeouts will be silently clipped to i32::MAX milliseconds.

Variants

After(Duration)

Timeout after a specific duration.

Never

Never timeout.

Implementations

impl Timeout

pub fn from_secs(seconds: u32) -> Self

Create a timeout with the specified number of seconds.

See Timeout for an important note about the maximum timeout.

Examples found in repository

examples/stdin.rs (line 14)

fn main() -> io::Result<()> {
    // Create a registry to hold I/O sources.
    let mut sources = popol::Sources::with_capacity(1);
    // Create an events buffer to hold readiness events.
    let mut events = Vec::with_capacity(1);

    // Register the program's standard input as a source of "read" readiness events.
    sources.register((), &io::stdin(), popol::interest::READ);

    // Wait on our event sources for at most 6 seconds. If an event source is
    // ready before then, process its events. Otherwise, timeout.
    match sources.poll(&mut events, popol::Timeout::from_secs(6)) {
        Ok(_) => {}
        Err(err) if err.kind() == io::ErrorKind::TimedOut => process::exit(1),
        Err(err) => return Err(err),
    }

    // Iterate over source events. Since we only have one source
    // registered, this will only iterate once.
    for event in events.drain(..) {
        // An error occured with the standard input.
        if event.is_error() {
            panic!("error on {:?}", io::stdin());
        }
        // The standard input has data ready to be read.
        if event.is_readable() || event.is_hangup() {
            let mut buf = [0; 1024];

            // Read what we can from standard input and echo it.
            match io::stdin().read(&mut buf[..]) {
                Ok(n) => io::stdout().write_all(&buf[..n])?,
                Err(err) => panic!("{}", err),
            }
        }
    }

    Ok(())
}

pub fn from_millis(milliseconds: u32) -> Self

Create a timeout with the specified number of milliseconds.

See Timeout for an important note about the maximum timeout.

Trait Implementations

impl Clone for Timeout

fn clone(&self) -> Timeout

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Timeout

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

Formats the value using the given formatter.

impl From<Duration> for Timeout

fn from(duration: Duration) -> Self

Create a timeout from a duration.

See Timeout for an important note about the maximum timeout.

impl From<Option<Duration>> for Timeout

fn from(duration: Option<Duration>) -> Self

Create a timeout from an optional duration.

See Timeout for an important note about the maximum timeout.