Struct tokio::timer::Timeout

#[must_use = "futures do nothing unless you `.await` or poll them"]
pub struct Timeout<T> { /* fields omitted */ }

Allows a Future or Stream to execute for a limited amount of time.

If the future or stream completes before the timeout has expired, then Timeout returns the completed value. Otherwise, Timeout returns an Error.

Futures and Streams

The exact behavor depends on if the inner value is a Future or a Stream. In the case of a Future, Timeout will require the future to complete by a fixed deadline. In the case of a Stream, Timeout will allow each item to take the entire timeout before returning an error.

In order to set an upper bound on the processing of the entire stream, then a timeout should be set on the future that processes the stream. For example:

#![feature(async_await)]

use tokio::prelude::*;
use tokio::sync::mpsc;

use std::thread;
use std::time::Duration;

let (mut tx, rx) = mpsc::unbounded_channel();

thread::spawn(move || {
    tx.try_send(()).unwrap();
    thread::sleep(Duration::from_millis(10));
    tx.try_send(()).unwrap();
});

let process = rx.for_each(|item| {
    // do something with `item`
});

// Wrap the future with a `Timeout` set to expire in 10 milliseconds.
process.timeout(Duration::from_millis(10)).await;

Cancelation

Cancelling a Timeout is done by dropping the value. No additional cleanup or other work is required.

The original future or stream may be obtained by calling Timeout::into_inner. This consumes the Timeout.

Methods

impl<T> Timeout<T>

Important traits for Timeout<T>

impl<T> Future for Timeout<T> where
    T: Future,  type Output = Result<<T as Future>::Output, Elapsed>;

pub fn new(value: T, timeout: Duration) -> Timeout<T>

Create a new Timeout that allows value to execute for a duration of at most timeout.

The exact behavior depends on if value is a Future or a Stream.

See type level documentation for more details.

Examples

Create a new Timeout set to expire in 10 milliseconds.

#![feature(async_await)]

use tokio::timer::Timeout;
use tokio::sync::oneshot;

use std::time::Duration;

let (tx, rx) = oneshot::channel();

// Wrap the future with a `Timeout` set to expire in 10 milliseconds.
Timeout::new(rx, Duration::from_millis(10)).await;
}

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

pub fn get_ref(&self) -> &T

Gets a reference to the underlying value in this timeout.

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

pub fn get_mut(&mut self) -> &mut T

Gets a mutable reference to the underlying value in this timeout.

pub fn into_inner(self) -> T

Consumes this timeout, returning the underlying value.

impl<T> Timeout<T> where
    T: Future, 

Important traits for Timeout<T>

impl<T> Future for Timeout<T> where
    T: Future,  type Output = Result<<T as Future>::Output, Elapsed>;

pub fn new_at(future: T, deadline: Instant) -> Timeout<T>

Create a new Timeout that completes when future completes or when deadline is reached.

This function differs from new in that:

• It only accepts Future arguments.
• It sets an explicit Instant at which the timeout expires.

Trait Implementations

impl<T> Debug for Timeout<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Stream for Timeout<T> where
    T: Stream, 

type Item = Result<<T as Stream>::Item, Elapsed>

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Timeout<T>>,
    cx: &mut Context
) -> Poll<Option<<Timeout<T> as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

impl<T> Future for Timeout<T> where
    T: Future, 

type Output = Result<<T as Future>::Output, Elapsed>

The type of value produced on completion.

fn poll(
    self: Pin<&mut Timeout<T>>,
    cx: &mut Context
) -> Poll<<Timeout<T> as Future>::Output>

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