pub struct Timer { /* private fields */ }
Expand description
A future or stream that emits timed events.
Timers are futures that output a single Instant
when they fire.
Timers are also streams that can output Instant
s periodically.
Examples
Sleep for 1 second:
use async_io::Timer;
use std::time::Duration;
Timer::after(Duration::from_secs(1)).await;
Timeout after 1 second:
use async_io::Timer;
use futures_lite::FutureExt;
use std::time::Duration;
let addrs = async_net::resolve("google.com:80")
.or(async {
Timer::after(Duration::from_secs(10)).await;
Err(std::io::ErrorKind::TimedOut.into())
})
.await?;
Implementations
sourceimpl Timer
impl Timer
sourcepub fn never() -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
pub fn never() -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
Creates a timer that will never fire.
Examples
This function may also be useful for creating a function with an optional timeout.
use async_io::Timer;
use futures_lite::prelude::*;
use std::time::Duration;
async fn run_with_timeout(timeout: Option<Duration>) {
let timer = timeout
.map(|timeout| Timer::after(timeout))
.unwrap_or_else(Timer::never);
run_lengthy_operation().or(timer).await;
}
// Times out after 5 seconds.
run_with_timeout(Some(Duration::from_secs(5))).await;
// Does not time out.
run_with_timeout(None).await;
sourcepub fn after(duration: Duration) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
pub fn after(duration: Duration) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
Creates a timer that emits an event once after the given duration of time.
Examples
use async_io::Timer;
use std::time::Duration;
Timer::after(Duration::from_secs(1)).await;
sourcepub fn at(instant: Instant) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
pub fn at(instant: Instant) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
Creates a timer that emits an event once at the given time instant.
Examples
use async_io::Timer;
use std::time::{Duration, Instant};
let now = Instant::now();
let when = now + Duration::from_secs(1);
Timer::at(when).await;
sourcepub fn interval(period: Duration) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
pub fn interval(period: Duration) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
Creates a timer that emits events periodically.
Examples
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};
let period = Duration::from_secs(1);
Timer::interval(period).next().await;
sourcepub fn interval_at(start: Instant, period: Duration) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
pub fn interval_at(start: Instant, period: Duration) -> TimerⓘNotable traits for Timerimpl Future for Timer type Output = Instant;
Creates a timer that emits events periodically, starting at start
.
Examples
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};
let start = Instant::now();
let period = Duration::from_secs(1);
Timer::interval_at(start, period).next().await;
sourcepub fn set_after(&mut self, duration: Duration)
pub fn set_after(&mut self, duration: Duration)
Sets the timer to emit an en event once after the given duration of time.
Note that resetting a timer is different from creating a new timer because
set_after()
does not remove the waker associated with the task
that is polling the timer.
Examples
use async_io::Timer;
use std::time::Duration;
let mut t = Timer::after(Duration::from_secs(1));
t.set_after(Duration::from_millis(100));
sourcepub fn set_at(&mut self, instant: Instant)
pub fn set_at(&mut self, instant: Instant)
Sets the timer to emit an event once at the given time instant.
Note that resetting a timer is different from creating a new timer because
set_at()
does not remove the waker associated with the task
that is polling the timer.
Examples
use async_io::Timer;
use std::time::{Duration, Instant};
let mut t = Timer::after(Duration::from_secs(1));
let now = Instant::now();
let when = now + Duration::from_secs(1);
t.set_at(when);
sourcepub fn set_interval(&mut self, period: Duration)
pub fn set_interval(&mut self, period: Duration)
Sets the timer to emit events periodically.
Note that resetting a timer is different from creating a new timer because
set_interval()
does not remove the waker associated with the
task that is polling the timer.
Examples
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};
let mut t = Timer::after(Duration::from_secs(1));
let period = Duration::from_secs(2);
t.set_interval(period);
sourcepub fn set_interval_at(&mut self, start: Instant, period: Duration)
pub fn set_interval_at(&mut self, start: Instant, period: Duration)
Sets the timer to emit events periodically, starting at start
.
Note that resetting a timer is different from creating a new timer because
set_interval_at()
does not remove the waker associated with
the task that is polling the timer.
Examples
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};
let mut t = Timer::after(Duration::from_secs(1));
let start = Instant::now();
let period = Duration::from_secs(2);
t.set_interval_at(start, period);
Trait Implementations
sourceimpl Stream for Timer
impl Stream for Timer
Auto Trait Implementations
impl RefUnwindSafe for Timer
impl Send for Timer
impl Sync for Timer
impl Unpin for Timer
impl UnwindSafe for Timer
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<F> FutureExt for Fwhere
F: Future + ?Sized,
impl<F> FutureExt for Fwhere
F: Future + ?Sized,
sourcefn race<F>(self, other: F) -> Race<Self, F>where
Self: Sized,
F: Future<Output = Self::Output>,
fn race<F>(self, other: F) -> Race<Self, F>where
Self: Sized,
F: Future<Output = Self::Output>,
sourcefn catch_unwind(self) -> CatchUnwind<Self>where
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self>where
Self: Sized + UnwindSafe,
sourceimpl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere
F: Future,
type IntoFuture = F
type IntoFuture = F
sourcefn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
sourceimpl<S> StreamExt for Swhere
S: Stream + ?Sized,
impl<S> StreamExt for Swhere
S: Stream + ?Sized,
sourcefn next(&mut self) -> NextFuture<'_, Self>where
Self: Unpin,
fn next(&mut self) -> NextFuture<'_, Self>where
Self: Unpin,
sourcefn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>where
Self: Stream<Item = Result<T, E>> + Unpin,
fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>where
Self: Stream<Item = Result<T, E>> + Unpin,
sourcefn count(self) -> CountFuture<Self>where
Self: Sized,
fn count(self) -> CountFuture<Self>where
Self: Sized,
sourcefn map<T, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> T,
fn map<T, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> T,
sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: Stream,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: Stream,
F: FnMut(Self::Item) -> U,
sourcefn flatten(self) -> Flatten<Self>where
Self: Sized,
Self::Item: Stream,
fn flatten(self) -> Flatten<Self>where
Self: Sized,
Self::Item: Stream,
sourcefn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>where
Self: Sized,
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>where
Self: Sized,
F: FnMut(Self::Item) -> Fut,
Fut: Future,
sourcefn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
sourcefn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<T>,
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<T>,
sourcefn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
items of the stream. Read moresourcefn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
sourcefn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
items of the stream. Read moresourcefn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
sourcefn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
step
th item. Read moresourcefn chain<U>(self, other: U) -> Chain<Self, U>where
Self: Sized,
U: Stream<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, U>where
Self: Sized,
U: Stream<Item = Self::Item>,
sourcefn cloned<'a, T>(self) -> Cloned<Self>where
Self: Stream<Item = &'a T> + Sized,
T: 'a + Clone,
fn cloned<'a, T>(self) -> Cloned<Self>where
Self: Stream<Item = &'a T> + Sized,
T: 'a + Clone,
sourcefn copied<'a, T>(self) -> Copied<Self>where
Self: Stream<Item = &'a T> + Sized,
T: 'a + Copy,
fn copied<'a, T>(self) -> Copied<Self>where
Self: Stream<Item = &'a T> + Sized,
T: 'a + Copy,
sourcefn collect<C>(self) -> CollectFuture<Self, C>where
Self: Sized,
C: Default + Extend<Self::Item>,
fn collect<C>(self) -> CollectFuture<Self, C>where
Self: Sized,
C: Default + Extend<Self::Item>,
sourcefn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C>where
Self: Stream<Item = Result<T, E>> + Sized,
C: Default + Extend<T>,
fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C>where
Self: Stream<Item = Result<T, E>> + Sized,
C: Default + Extend<T>,
sourcefn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B>where
Self: Sized,
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B>where
Self: Sized,
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
predicate
is true
and those for which it is
false
, and then collects them into two collections. Read moresourcefn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>where
Self: Sized,
F: FnMut(T, Self::Item) -> T,
fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>where
Self: Sized,
F: FnMut(T, Self::Item) -> T,
sourcefn try_fold<T, E, F, B>(&mut self, init: B, f: F) -> TryFoldFuture<'_, Self, F, B>where
Self: Stream<Item = Result<T, E>> + Unpin + Sized,
F: FnMut(B, T) -> Result<B, E>,
fn try_fold<T, E, F, B>(&mut self, init: B, f: F) -> TryFoldFuture<'_, Self, F, B>where
Self: Stream<Item = Result<T, E>> + Unpin + Sized,
F: FnMut(B, T) -> Result<B, E>,
sourcefn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
sourcefn cycle(self) -> Cycle<Self>where
Self: Clone + Sized,
fn cycle(self) -> Cycle<Self>where
Self: Clone + Sized,
sourcefn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
(index, item)
. Read moresourcefn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
sourcefn nth(&mut self, n: usize) -> NthFuture<'_, Self>where
Self: Unpin,
fn nth(&mut self, n: usize) -> NthFuture<'_, Self>where
Self: Unpin,
n
th item of the stream. Read moresourcefn last(self) -> LastFuture<Self>where
Self: Sized,
fn last(self) -> LastFuture<Self>where
Self: Sized,
sourcefn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(&Self::Item) -> bool,
sourcefn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>where
Self: Unpin,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>where
Self: Unpin,
F: FnMut(Self::Item) -> Option<B>,
sourcefn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
sourcefn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
sourcefn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P>where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
sourcefn for_each<F>(self, f: F) -> ForEachFuture<Self, F>where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F) -> ForEachFuture<Self, F>where
Self: Sized,
F: FnMut(Self::Item),
sourcefn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F>where
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F>where
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
sourcefn zip<U>(self, other: U) -> Zip<Self, U>where
Self: Sized,
U: Stream,
fn zip<U>(self, other: U) -> Zip<Self, U>where
Self: Sized,
U: Stream,
sourcefn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB>where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)> + Sized,
fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB>where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)> + Sized,
sourcefn race<S>(self, other: S) -> Race<Self, S>where
Self: Sized,
S: Stream<Item = Self::Item>,
fn race<S>(self, other: S) -> Race<Self, S>where
Self: Sized,
S: Stream<Item = Self::Item>,
other
stream, with no preference for either stream when both are ready. Read more