actix_rt::time

# Struct Sleep

    pub struct Sleep { /* private fields */ }

Expand description

Future returned by `sleep` and `sleep_until`.

This type does not implement the `Unpin` trait, which means that if you use it with `select!` or by calling `poll`, you have to pin it first. If you use it with `.await`, this does not apply.

## §Examples

Wait 100ms and print “100 ms have elapsed”.

    use tokio::time::{sleep, Duration};

    #[tokio::main]
    async fn main() {
        sleep(Duration::from_millis(100)).await;
        println!("100 ms have elapsed");
    }

Use with `select!`. Pinning the `Sleep` with `tokio::pin!` is necessary when the same `Sleep` is selected on multiple times.

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

    #[tokio::main]
    async fn main() {
        let sleep = time::sleep(Duration::from_millis(10));
        tokio::pin!(sleep);

        loop {
            tokio::select! {
                () = &mut sleep => {
                    println!("timer elapsed");
                    sleep.as_mut().reset(Instant::now() + Duration::from_millis(50));
                },
            }
        }
    }

Use in a struct with boxing. By pinning the `Sleep` with a `Box`, the `HasSleep` struct implements `Unpin`, even though `Sleep` does not.

    use std::future::Future;
    use std::pin::Pin;
    use std::task::{Context, Poll};
    use tokio::time::Sleep;

    struct HasSleep {
        sleep: Pin<Box<Sleep>>,
    }

    impl Future for HasSleep {
        type Output = ();

        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
            self.sleep.as_mut().poll(cx)
        }
    }

Use in a struct with pin projection. This method avoids the `Box`, but the `HasSleep` struct will not be `Unpin` as a consequence.

    use std::future::Future;
    use std::pin::Pin;
    use std::task::{Context, Poll};
    use tokio::time::Sleep;
    use pin_project_lite::pin_project;

    pin_project! {
        struct HasSleep {
            #[pin]
            sleep: Sleep,
        }
    }

    impl Future for HasSleep {
        type Output = ();

        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
            self.project().sleep.poll(cx)
        }
    }

## Implementations§

§

### impl Sleep

#### pub fn deadline(&self) -> Instant

Returns the instant at which the future will complete.

#### pub fn is_elapsed(&self) -> bool

Returns `true` if `Sleep` has elapsed.

A `Sleep` instance is elapsed when the requested duration has elapsed.

#### pub fn reset(self: Pin<&mut Sleep>, deadline: Instant)

Resets the `Sleep` instance to a new deadline.

Calling this function allows changing the instant at which the `Sleep` future completes without having to create new associated state.

This function can be called both before and after the future has completed.

To call this method, you will usually combine the call with `Pin::as_mut`, which lets you call the method without consuming the `Sleep` itself.

##### §Example

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

    let sleep = tokio::time::sleep(Duration::from_millis(10));
    tokio::pin!(sleep);

    sleep.as_mut().reset(Instant::now() + Duration::from_millis(20));

See also the top-level examples.

## Trait Implementations§

§

### impl Debug for Sleep

§

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

Formats the value using the given formatter. Read more
§

### impl Future for Sleep

§

#### type Output = ()

The type of value produced on completion.
§

#### fn poll( self: Pin<&mut Sleep>, cx: &mut Context<'_>, ) -> Poll<<Sleep as Future>::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

## Auto Trait Implementations§

§

### impl !Freeze for Sleep

§

### impl !RefUnwindSafe for Sleep

§

### impl Send for Sleep

§

### impl Sync for Sleep

§

### impl !UnwindSafe for Sleep

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

§

### impl<T> FutureExt for T
where T: Future + ?Sized,

§

#### fn map<U, F>(self, f: F) -> Map<Self, F>
where F: FnOnce(Self::Output) -> U, Self: Sized,

Map this future’s output to a different type, returning a new future of the resulting type. Read more
§

#### fn map_into<U>(self) -> MapInto<Self, U>
where Self::Output: Into<U>, Self: Sized,

Map this future’s output to a different type, returning a new future of the resulting type. Read more
§

#### fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
where F: FnOnce(Self::Output) -> Fut, Fut: Future, Self: Sized,

Chain on a computation for when a future finished, passing the result of the future to the provided closure `f`. Read more
§

#### fn left_future<B>(self) -> Either<Self, B>
where B: Future<Output = Self::Output>, Self: Sized,

Wrap this future in an `Either` future, making it the left-hand variant of that `Either`. Read more
§

#### fn right_future<A>(self) -> Either<A, Self>
where A: Future<Output = Self::Output>, Self: Sized,

Wrap this future in an `Either` future, making it the right-hand variant of that `Either`. Read more
§

#### fn into_stream(self) -> IntoStream<Self>
where Self: Sized,

Convert this future into a single element stream. Read more
§

#### fn flatten(self) -> Flatten<Self>
where Self::Output: Future, Self: Sized,

Flatten the execution of this future when the output of this future is itself another future. Read more
§

#### fn flatten_stream(self) -> FlattenStream<Self>
where Self::Output: Stream, Self: Sized,

Flatten the execution of this future when the successful result of this future is a stream. Read more
§

#### fn fuse(self) -> Fuse<Self>
where Self: Sized,

Fuse a future such that `poll` will never again be called once it has completed. This method can be used to turn any `Future` into a `FusedFuture`. Read more
§

#### fn inspect<F>(self, f: F) -> Inspect<Self, F>
where F: FnOnce(&Self::Output), Self: Sized,

Do something with the output of a future before passing it on. Read more
§

#### fn catch_unwind(self) -> CatchUnwind<Self>
where Self: Sized + UnwindSafe,

Catches unwinding panics while polling the future. Read more
§

#### fn shared(self) -> Shared<Self>
where Self: Sized, Self::Output: Clone,

Create a cloneable handle to this future where all handles will resolve to the same result. Read more
§

#### fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a>>
where Self: Sized + Send + 'a,

Wrap the future in a Box, pinning it. Read more
§

#### fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>
where Self: Sized + 'a,

Wrap the future in a Box, pinning it. Read more
§

#### fn unit_error(self) -> UnitError<Self>
where Self: Sized,

Turns a `Future<Output = T>` into a `TryFuture<Ok = T, Error = ()`>.
§

#### fn never_error(self) -> NeverError<Self>
where Self: Sized,

Turns a `Future<Output = T>` into a `TryFuture<Ok = T, Error = Never`>.
§

#### fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>
where Self: Unpin,

A convenience for calling `Future::poll` on `Unpin` future types.
§

#### fn now_or_never(self) -> Option<Self::Output>
where Self: Sized,

Evaluates and consumes the future, returning the resulting output if the future is ready after the first call to `Future::poll`. Read more
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<F> IntoFuture for F
where F: Future,

source §

#### type Output = <F as Future>::Output

The output that the future will produce on completion.
source §

#### type IntoFuture = F

Which kind of future are we turning this into?
source §

#### fn into_future(self) -> <F as IntoFuture>::IntoFuture

Creates a future from a value. Read more
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.