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.

Note

Returned Interval is already armed, so it don't need initial poll to start.

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.

Methods

impl Interval

pub fn platform_new(interval: Duration) -> Self

Creates new instance using platform timer

impl<T: Oneshot> 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, ctx: &Context)

Restarts interval

pub fn as_mut(&mut self) -> &mut Self

Gets mutable reference

Trait Implementations

impl<'_, T: Oneshot> 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.