Struct async_shared_timeout::Timeout

pub struct Timeout<R: Runtime> { /* private fields */ }

A shared timeout.

Example

use std::time::Duration;

let timeout_secs = Duration::from_secs(10);
// Use the tokio runtime
let runtime = async_shared_timeout::runtime::Tokio::new();
let timeout = async_shared_timeout::Timeout::new(runtime, timeout_secs);
tokio::select! {
    _ = timeout.wait() => {
        println!("timeout expired!");
    }
    _ = async {
        while let Some(cmd) = read_command().await {
            println!("command received: {:?}", cmd);
            timeout.reset();
        }
    } => {
        println!("no more commands!");
    }
}

Implementations

impl<R: Runtime> Timeout<R>

pub fn new(runtime: R, default_timeout: Duration) -> Self

Create a new timeout that expires after default_timeout

Panics

Panics if default_timeout is longer than ~584 years

pub fn reset(&self)

Reset the timeout to the default time.

This function is cheap to call.

Panics

Panics if over ~584 years have elapsed since the timer started.

pub fn default_timeout(&self) -> Duration

The default timeout. Timeout will be reset to this value upon a successful operation.

pub fn set_default_timeout(&self, default_timeout: Duration)

Change the default timeout.

Warning: if this timeout is shorter than previous one, it will only update after the previous timeout has expired!

Panics

Panics if default_timeout is longer than ~584 years

pub async fn wait(&self)

Wait for the timeout to expire

This is a function that’s expensive to start, so for best performance, only call it once per timer - launch it separately and call reset from the other futures (see the example in top-level documentation).

Trait Implementations

impl<R: Debug + Runtime> Debug for Timeout<R>where
    R::Instant: Debug,

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

Formats the value using the given formatter.