Struct async_io::Timer

[+] Show declaration

pub struct Timer { /* fields omitted */ }

[−] Expand description

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 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[+]

[+] Show hidden undocumented items

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

Formats the value using the given formatter.

impl Drop for Timer[+]

[+] Show hidden undocumented items

fn drop(&mut self)[−]

Executes the destructor for this type.

impl Future for Timer[+]

[+] Show hidden undocumented items

type Output = Instant

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>[−]

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

impl Stream for Timer[+]

[+] Show hidden undocumented items

type Item = Instant

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::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.

pub fn size_hint(&self) -> (usize, Option<usize>)[−]

Returns the bounds on the remaining length of the stream.