Struct async_timer::Interval

pub struct Interval<T = Platform> {
    pub interval: Duration,
    /* private fields */
}

Periodic Timer

On each completion, underlying timer is restarted and therefore Future can be polled once more.

Usage

async fn job() {
}

async fn do_a_while() {
    let mut times: u8 = 0;
    let mut interval = async_timer::Interval::platform_new(core::time::Duration::from_secs(1));

    while times < 5 {
        job().await;
        interval.wait().await;
        times += 1;
    }
}

Fields

interval: Duration

Timer interval, change to this value will be reflected on next restart of timer.

Implementations

impl Interval

pub fn platform_new(interval: Duration) -> Self

Creates new instance using platform timer

impl<T: Timer> Interval<T>

pub fn new(interval: Duration) -> Self

Creates new instance with specified timer type.

pub fn cancel(&mut self)

Stops interval

pub fn restart(&mut self)

Restarts interval

pub fn wait<'a>(&'a mut self) -> impl Future<Output = ()> + 'a

Returns future for next expiration.

Trait Implementations

impl<T: Timer> Future for &mut Interval<T>

type Output = ()

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, ctx: &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.