Struct heph_rt::timer::Interval

pub struct Interval<RT: Access> { /* private fields */ }

An AsyncIterator that yields an item after an interval has passed.

This itertor will never return None, it will always set another deadline and yield another item after the deadline has passed.

Notes

The next deadline will always will be set after this returns Poll::Ready. This means that if the interval is very short and the iterator is not polled often enough it’s possible that the actual time between yielding two values can become bigger then the specified interval.

Examples

The following example will print hello world (roughly) every 200 milliseconds.

use std::time::Duration;

use heph::actor;
use heph_rt::ThreadLocal;
use heph_rt::timer::Interval;
use heph_rt::util::next;

async fn actor(mut ctx: actor::Context<!, ThreadLocal>) {
    let mut interval = Interval::every(&mut ctx, Duration::from_millis(200));
    loop {
        // Wait until the next timer expires.
        let _ = next(&mut interval).await;
        println!("Hello world");
    }
}

Implementations

impl<RT: Access> Interval<RT>

pub fn every<M>(ctx: &mut Context<M, RT>, interval: Duration) -> Interval<RT>where
    RT: Clone,

Create a new Interval.

pub const fn next_deadline(&self) -> Instant

Returns the next deadline for this Interval.

Trait Implementations

impl<RT: Access> AsyncIterator for Interval<RT>

type Item = DeadlinePassed

🔬This is a nightly-only experimental API. (async_iterator)

The type of items yielded by the async iterator.

fn poll_next(
    self: Pin<&mut Self>,
    _: &mut Context<'_>
) -> Poll<Option<Self::Item>>

🔬This is a nightly-only experimental API. (async_iterator)

Attempt to pull out the next value of this async iterator, registering the current task for wakeup if the value is not yet available, and returning None if the async iterator is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

🔬This is a nightly-only experimental API. (async_iterator)

Returns the bounds on the remaining length of the async iterator.

impl<RT: Access> Bound<RT> for Interval<RT>

type Error = !

Error type used in bind_to.

fn bind_to<M>(&mut self, ctx: &mut Context<M, RT>) -> Result<(), !>

Bind a type to the Actor that owns the ctx.

impl<RT: Debug + Access> Debug for Interval<RT>

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

Formats the value using the given formatter.

impl<RT: Access> Drop for Interval<RT>

fn drop(&mut self)

Executes the destructor for this type.

impl<RT: Access> Unpin for Interval<RT>