mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-18 00:00:09 +02:00
David Kellum
491f15827b
* Normalize links to docs.rs/CRATE/M.N/... docs.rs is smart enough to show docs for the latest M.N.P release when M.N is used in the link. For example: https://docs.rs/mio/0.6/mio/struct.Poll.html ..will show mio 0.6.14 and later docs. While using the `M.N.*` (ASTERISK) syntax also works, `M.N` is the more common usage, so standarize a few existing links to that format. * Fix missing or malformed rustdoc links * executor lib rustdoc minor format change * Promote tokio-threadpool crate level comments to rustdoc * Replace hidden tokio::executor::thread_pool docs with deprecation note * Fix typo/simplify util module rustdoc * Reuse some tokio::executor::thread_pool rustdoc for the crate Relates to #421
90 lines
2.5 KiB
Rust
90 lines
2.5 KiB
Rust
//! 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.
|
|
//!
|
|
//! * [`Deadline`][Deadline] wraps a future, requiring that it completes before
|
|
//! a specified `Instant` in time. If the future does not complete in time,
|
|
//! then it is canceled and an error is returned.
|
|
//!
|
|
//! 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
|
|
//! [`deadline`][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() {
|
|
//! let when = Instant::now() + Duration::from_millis(300);
|
|
//!
|
|
//! tokio::run({
|
|
//! long_op()
|
|
//! .deadline(when)
|
|
//! .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.deadline
|
|
//! [Deadline]: struct.Deadline.html
|
|
//! [Delay]: struct.Delay.html
|
|
//! [Interval]: struct.Interval.html
|
|
|
|
pub use tokio_timer::{
|
|
Deadline,
|
|
DeadlineError,
|
|
Error,
|
|
Interval,
|
|
Delay,
|
|
};
|