actix_rt::time

# Struct Interval

    pub struct Interval { /* private fields */ }

Expand description

Interval returned by `interval` and `interval_at`.

This type allows you to wait on a sequence of instants with a certain duration between each instant. Unlike calling `sleep` in a loop, this lets you count the time spent between the calls to `sleep` as well.

An `Interval` can be turned into a `Stream` with `IntervalStream`.

## Implementations§

§

### impl Interval

#### pub async fn tick(&mut self) -> Instant

Completes when the next instant in the interval has been reached.

##### §Cancel safety

This method is cancellation safe. If `tick` is used as the branch in a `tokio::select!` and another branch completes first, then no tick has been consumed.

##### §Examples

    use tokio::time;

    use std::time::Duration;

    #[tokio::main]
    async fn main() {
        let mut interval = time::interval(Duration::from_millis(10));

        interval.tick().await;
        // approximately 0ms have elapsed. The first tick completes immediately.
        interval.tick().await;
        interval.tick().await;

        // approximately 20ms have elapsed.
    }

#### pub fn poll_tick(&mut self, cx: &mut Context<'_>) -> Poll<Instant>

Polls for the next instant in the interval to be reached.

This method can return the following values:

- `Poll::Pending` if the next instant has not yet been reached.
- `Poll::Ready(instant)` if the next instant has been reached.

When this method returns `Poll::Pending`, the current task is scheduled to receive a wakeup when the instant has elapsed. Note that on multiple calls to `poll_tick`, only the `Waker` from the `Context` passed to the most recent call is scheduled to receive a wakeup.

#### pub fn reset(&mut self)

Resets the interval to complete one period after the current time.

This method ignores [`MissedTickBehavior`] strategy.

This is equivalent to calling `reset_at(Instant::now() + period)`.

##### §Examples

    use tokio::time;

    use std::time::Duration;

    #[tokio::main]
    async fn main() {
        let mut interval = time::interval(Duration::from_millis(100));

        interval.tick().await;

        time::sleep(Duration::from_millis(50)).await;
        interval.reset();

        interval.tick().await;
        interval.tick().await;

        // approximately 250ms have elapsed.
    }

#### pub fn reset_immediately(&mut self)

Resets the interval immediately.

This method ignores [`MissedTickBehavior`] strategy.

This is equivalent to calling `reset_at(Instant::now())`.

##### §Examples

    use tokio::time;

    use std::time::Duration;

    #[tokio::main]
    async fn main() {
        let mut interval = time::interval(Duration::from_millis(100));

        interval.tick().await;

        time::sleep(Duration::from_millis(50)).await;
        interval.reset_immediately();

        interval.tick().await;
        interval.tick().await;

        // approximately 150ms have elapsed.
    }

#### pub fn reset_after(&mut self, after: Duration)

Resets the interval after the specified `std::time::Duration`.

This method ignores [`MissedTickBehavior`] strategy.

This is equivalent to calling `reset_at(Instant::now() + after)`.

##### §Examples

    use tokio::time;

    use std::time::Duration;

    #[tokio::main]
    async fn main() {
        let mut interval = time::interval(Duration::from_millis(100));
        interval.tick().await;

        time::sleep(Duration::from_millis(50)).await;

        let after = Duration::from_millis(20);
        interval.reset_after(after);

        interval.tick().await;
        interval.tick().await;

        // approximately 170ms have elapsed.
    }

#### pub fn reset_at(&mut self, deadline: Instant)

Resets the interval to a `crate::time::Instant` deadline.

Sets the next tick to expire at the given instant. If the instant is in the past, then the [`MissedTickBehavior`] strategy will be used to catch up. If the instant is in the future, then the next tick will complete at the given instant, even if that means that it will sleep for longer than the duration of this `Interval`. If the `Interval` had any missed ticks before calling this method, then those are discarded.

##### §Examples

    use tokio::time::{self, Instant};

    use std::time::Duration;

    #[tokio::main]
    async fn main() {
        let mut interval = time::interval(Duration::from_millis(100));
        interval.tick().await;

        time::sleep(Duration::from_millis(50)).await;

        let deadline = Instant::now() + Duration::from_millis(30);
        interval.reset_at(deadline);

        interval.tick().await;
        interval.tick().await;

        // approximately 180ms have elapsed.
    }

#### pub fn missed_tick_behavior(&self) -> MissedTickBehavior

Returns the [`MissedTickBehavior`] strategy currently being used.

#### pub fn set_missed_tick_behavior(&mut self, behavior: MissedTickBehavior)

Sets the [`MissedTickBehavior`] strategy that should be used.

#### pub fn period(&self) -> Duration

Returns the period of the interval.

## Trait Implementations§

§

### impl Debug for Interval

§

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

Formats the value using the given formatter. Read more

## Auto Trait Implementations§

§

### impl Freeze for Interval

§

### impl !RefUnwindSafe for Interval

§

### impl Send for Interval

§

### impl Sync for Interval

§

### impl Unpin for Interval

§

### impl !UnwindSafe for Interval

## Blanket Implementations§

source §

### impl<T> Any for T
where T: 'static + ?Sized,

source §

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source §

### impl<T> Borrow<T> for T
where T: ?Sized,

source §

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source §

### impl<T> BorrowMut<T> for T
where T: ?Sized,

source §

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source §

### impl<T> From<T> for T

source §

#### fn from(t: T) -> T

Returns the argument unchanged.

source §

### impl<T, U> Into<U> for T
where U: From<T>,

source §

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source §

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

source §

#### type Error = Infallible

The type returned in the event of a conversion error.
source §

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source §

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source §

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source §

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.