Struct async_interval::impl_async_timer::Interval

pub struct Interval<T = PosixTimer> {
    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<PosixTimer>

pub fn platform_new(interval: Duration) -> Interval<PosixTimer>

Creates new instance using platform timer

impl<T> Interval<T>where
    T: Timer,

pub fn new(interval: Duration) -> Interval<T>

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> Future for &mut Interval<T>where
    T: Timer,

type Output = ()

The type of value produced on completion.

fn poll(
    self: Pin<&mut &mut Interval<T>>,
    ctx: &mut Context<'_>
) -> Poll<<&mut Interval<T> 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 Interval

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