Enum async_timers::OneshotTimer

pub enum OneshotTimer {
    Scheduled(Instant),
    Expired,
}

OneshotTimer expires once after a given duration

OneshotTimer is used for tasks that need to be executed once after some delay. OneshotTimer is an extension and built on top of tokio::time::Sleep. In OneshotTimer::Scheduled state it will expire once and transition into OneshotTimer::Expired state.

use async_timers::OneshotTimer;
use tokio::time::{Duration, timeout};

#[tokio::main]
async fn main() {
    let mut timer = OneshotTimer::scheduled(Duration::from_millis(10));

    timer.tick().await;

    // approximately 10ms have elapsed.

    let result = timeout(Duration::from_millis(100), timer.tick()).await;
    assert!(result.is_err(), "Timeout should occur since timer is expired");

    timer.schedule(Duration::from_millis(30));

    let result = timeout(Duration::from_millis(100), timer.tick()).await;
    assert!(result.is_ok(), "Timeout should not occur since timer has been scheduled");
}

Variants

Scheduled(Instant)

Expired

Implementations

impl OneshotTimer

pub fn scheduled(duration: Duration) -> Self

Create a timer scheduled to be expired after duration

pub fn expired() -> Self

Create a timer that won’t expire

pub fn schedule(&mut self, duration: Duration)

Schedule a new duration

pub fn cancel(&mut self)

Cancel the timer

pub async fn tick(&mut self)

Returns a Future that will expire based on timer’s state

Trait Implementations

impl Debug for OneshotTimer

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

Formats the value using the given formatter.

impl Default for OneshotTimer

fn default() -> OneshotTimer

Returns the “default value” for a type.