1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
//! Utilities for tracking time. //! //! This module provides a number of types for executing code after a set period //! of time. //! //! * [`Delay`][Delay] is a future that does no work and completes at a specific `Instant` //! in time. //! //! * [`Interval`][Interval] is a stream yielding a value at a fixed period. It //! is initialized with a `Duration` and repeatedly yields each time the //! duration elapses. //! //! * [`Timeout`][Timeout]: Wraps a future or stream, setting an upper bound to the //! amount of time it is allowed to execute. If the future or stream does not //! complete in time, then it is canceled and an error is returned. //! //! * [`DelayQueue`]: A queue where items are returned once the requested delay //! has expired. //! //! These types are sufficient for handling a large number of scenarios //! involving time. //! //! These types must be used from within the context of the //! [`Runtime`][runtime] or a timer context must be setup explicitly. See the //! [`tokio-timer`][tokio-timer] crate for more details on how to setup a timer //! context. //! //! # Examples //! //! Wait 100ms and print "Hello World!" //! //! ``` //! use tokio::prelude::*; //! use tokio::timer::Delay; //! //! use std::time::{Duration, Instant}; //! //! let when = Instant::now() + Duration::from_millis(100); //! //! tokio::run({ //! Delay::new(when) //! .map_err(|e| panic!("timer failed; err={:?}", e)) //! .and_then(|_| { //! println!("Hello world!"); //! Ok(()) //! }) //! }) //! ``` //! //! Require that an operation takes no more than 300ms. Note that this uses the //! [`timeout`][ext] function on the [`FutureExt`][ext] trait. This trait is //! included in the prelude. //! //! ``` //! # extern crate futures; //! # extern crate tokio; //! use tokio::prelude::*; //! //! use std::time::{Duration, Instant}; //! //! fn long_op() -> Box<Future<Item = (), Error = ()> + Send> { //! // ... //! # Box::new(futures::future::ok(())) //! } //! //! # fn main() { //! tokio::run({ //! long_op() //! .timeout(Duration::from_millis(300)) //! .map_err(|e| { //! println!("operation timed out"); //! }) //! }) //! # } //! ``` //! //! [runtime]: ../runtime/struct.Runtime.html //! [tokio-timer]: https://docs.rs/tokio-timer //! [ext]: ../util/trait.FutureExt.html#method.timeout //! [Timeout]: struct.Timeout.html //! [Delay]: struct.Delay.html //! [Interval]: struct.Interval.html //! [`DelayQueue`]: struct.DelayQueue.html pub use tokio_timer::{delay_queue, timeout, Delay, DelayQueue, Error, Interval, Timeout}; #[deprecated(since = "0.1.8", note = "use Timeout instead")] #[allow(deprecated)] #[doc(hidden)] pub type Deadline<T> = ::tokio_timer::Deadline<T>; #[deprecated(since = "0.1.8", note = "use Timeout instead")] #[allow(deprecated)] #[doc(hidden)] pub type DeadlineError<T> = ::tokio_timer::DeadlineError<T>;