Struct async_interval::impl_async_io::Timer

pub struct Timer { /* private fields */ }

A future or stream that emits timed events.

Timers are futures that output a single Instant when they fire.

Timers are also streams that can output Instants periodically.

Examples

Sleep for 1 second:

use async_io::Timer;
use std::time::Duration;

Timer::after(Duration::from_secs(1)).await;

Timeout after 1 second:

use async_io::Timer;
use futures_lite::FutureExt;
use std::time::Duration;

let addrs = async_net::resolve("google.com:80")
    .or(async {
        Timer::after(Duration::from_secs(10)).await;
        Err(std::io::ErrorKind::TimedOut.into())
    })
    .await?;

Implementations

impl Timer

pub fn never() -> Timer

Creates a timer that will never fire.

Examples

This function may also be useful for creating a function with an optional timeout.

use async_io::Timer;
use futures_lite::prelude::*;
use std::time::Duration;

async fn run_with_timeout(timeout: Option<Duration>) {
    let timer = timeout
        .map(|timeout| Timer::after(timeout))
        .unwrap_or_else(Timer::never);

    run_lengthy_operation().or(timer).await;
}

// Times out after 5 seconds.
run_with_timeout(Some(Duration::from_secs(5))).await;
// Does not time out.
run_with_timeout(None).await;

pub fn after(duration: Duration) -> Timer

Creates a timer that emits an event once after the given duration of time.

Examples

use async_io::Timer;
use std::time::Duration;

Timer::after(Duration::from_secs(1)).await;

pub fn at(instant: Instant) -> Timer

Creates a timer that emits an event once at the given time instant.

Examples

use async_io::Timer;
use std::time::{Duration, Instant};

let now = Instant::now();
let when = now + Duration::from_secs(1);
Timer::at(when).await;

pub fn interval(period: Duration) -> Timer

Creates a timer that emits events periodically.

Examples

use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let period = Duration::from_secs(1);
Timer::interval(period).next().await;

pub fn interval_at(start: Instant, period: Duration) -> Timer

Creates a timer that emits events periodically, starting at start.

Examples

use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let start = Instant::now();
let period = Duration::from_secs(1);
Timer::interval_at(start, period).next().await;

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

Sets the timer to emit an en event once after the given duration of time.

Note that resetting a timer is different from creating a new timer because set_after() does not remove the waker associated with the task that is polling the timer.

Examples

use async_io::Timer;
use std::time::Duration;

let mut t = Timer::after(Duration::from_secs(1));
t.set_after(Duration::from_millis(100));

pub fn set_at(&mut self, instant: Instant)

Sets the timer to emit an event once at the given time instant.

Note that resetting a timer is different from creating a new timer because set_at() does not remove the waker associated with the task that is polling the timer.

Examples

use async_io::Timer;
use std::time::{Duration, Instant};

let mut t = Timer::after(Duration::from_secs(1));

let now = Instant::now();
let when = now + Duration::from_secs(1);
t.set_at(when);

pub fn set_interval(&mut self, period: Duration)

Sets the timer to emit events periodically.

Note that resetting a timer is different from creating a new timer because set_interval() does not remove the waker associated with the task that is polling the timer.

Examples

use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let mut t = Timer::after(Duration::from_secs(1));

let period = Duration::from_secs(2);
t.set_interval(period);

pub fn set_interval_at(&mut self, start: Instant, period: Duration)

Sets the timer to emit events periodically, starting at start.

Note that resetting a timer is different from creating a new timer because set_interval_at() does not remove the waker associated with the task that is polling the timer.

Examples

use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let mut t = Timer::after(Duration::from_secs(1));

let start = Instant::now();
let period = Duration::from_secs(2);
t.set_interval_at(start, period);

Trait Implementations

impl Debug for Timer

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

Formats the value using the given formatter.

impl Drop for Timer

fn drop(&mut self)

Executes the destructor for this type.

impl Future for Timer

type Output = Instant

The type of value produced on completion.

fn poll(
    self: Pin<&mut Timer>,
    cx: &mut Context<'_>
) -> Poll<<Timer as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl Intervalable for Timer

fn interval(dur: Duration) -> Self

fn wait<'a>(&'a mut self) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>

fn wait_for_std<'a>(
    &'a mut self
) -> Pin<Box<dyn Future<Output = Option<Instant>> + Send + 'a>>

impl Stream for Timer

type Item = Instant

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Timer>,
    cx: &mut Context<'_>
) -> Poll<Option<<Timer as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.