Struct ntex::rt::time::Sleep [−][src]
#[must_use = "futures do nothing unless you `.await` or poll them"]pub struct Sleep { /* fields omitted */ }
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
[src]
impl Sleep
[src]pub fn is_elapsed(&self) -> bool
[src]
pub fn is_elapsed(&self) -> bool
[src]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)
[src]
pub fn reset(self: Pin<&mut Sleep>, deadline: Instant)
[src]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));
Trait Implementations
impl<'__pin> Unpin for Sleep where
__Origin<'__pin>: Unpin,
[src]
__Origin<'__pin>: Unpin,
Auto Trait Implementations
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> FutureExt for T where
T: Future + ?Sized,
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,
fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
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>,
fn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,
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,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
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>,
fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
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>,
fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
Wrap this future in an Either
future, making it the right-hand variant
of that Either
. Read more
fn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
Convert this future into a single element stream. Read more
fn flatten(self) -> Flatten<Self> where
Self::Output: Future,
fn flatten(self) -> Flatten<Self> where
Self::Output: Future,
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,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
Flatten the execution of this future when the successful result of this future is a stream. Read more
fn fuse(self) -> Fuse<Self>
fn fuse(self) -> Fuse<Self>
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),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
Do something with the output of a future before passing it on. Read more
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
Catches unwinding panics while polling the future. Read more
fn shared(self) -> Shared<Self> where
Self::Output: Clone,
fn shared(self) -> Shared<Self> where
Self::Output: Clone,
Create a cloneable handle to this future where all handles will resolve to the same result. Read more
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
Turn this future into a future that yields ()
on completion and sends
its output to another future on a separate task. Read more
fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where
Self: Send + 'a,
fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where
Self: 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, Global>> where
Self: 'a,
fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where
Self: 'a,
Wrap the future in a Box, pinning it. Read more
fn unit_error(self) -> UnitError<Self>
fn unit_error(self) -> UnitError<Self>
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = ()
>. Read more
fn never_error(self) -> NeverError<Self>
fn never_error(self) -> NeverError<Self>
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = Never
>. Read more
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
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>
fn now_or_never(self) -> Option<Self::Output>
Evaluates and consumes the future, returning the resulting output if
the future is ready after the first call to Future::poll
. Read more
impl<T> Instrument for T
[src]
impl<T> Instrument for T
[src]fn instrument(self, span: Span) -> Instrumented<Self>
[src]
fn instrument(self, span: Span) -> Instrumented<Self>
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
fn in_current_span(self) -> Instrumented<Self>
[src]
fn in_current_span(self) -> Instrumented<Self>
[src]impl<F> IntoFuture for F where
F: Future,
[src]
impl<F> IntoFuture for F where
F: Future,
[src]type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
type Future = F
into_future
)Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]into_future
)Creates a future from a value.
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self