Struct async_timer::Interval

#[must_use = "Interval does nothing unless polled"]pub struct Interval<T = PlatformTimer> {
    pub interval: Duration,
    // some fields omitted
}

Periodic Timer

On each completition, 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.as_mut().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 as_mut(&mut self) -> &mut Self

Gets mutable reference

Trait Implementations

impl<T: Timer, '_> Future for &'_ mut Interval<T>

type Output = ()

The type of value produced on completion.

pub 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.