[−][src]Trait runtime::time::FutureExt

pub trait FutureExt: Future + Sized + Unpin {
    fn timeout(self, dur: Duration) -> Timeout<Self> { ... }

    fn timeout_at(self, at: Instant) -> Timeout<Self> { ... }
}

Extend Future with methods to time out execution.

Provided methods

ⓘImportant traits for Timeout<F>
fn timeout(self, dur: Duration) -> Timeout<Self>

Creates a new future which will take at most dur time to resolve from the point at which this method is called.

This combinator creates a new future which wraps the receiving future in a timeout. The future returned will resolve in at most dur time specified (relative to when this function is called).

If the future completes before dur elapses then the future will resolve with that item. Otherwise the future will resolve to an error once dur has elapsed.

Examples

use futures::prelude::*;
use runtime::prelude::*;
use std::time::Duration;

#[runtime::main]
async fn main() {
    let future = long_future();
    let timed_out = future.timeout(Duration::from_millis(100));

    match timed_out.await {
        Ok(item) => println!("got {:?} within enough time!", item),
        Err(_) => println!("took too long to produce the item"),
    }
}

ⓘImportant traits for Timeout<F>
fn timeout_at(self, at: Instant) -> Timeout<Self>

Creates a new future which will resolve no later than at specified.

This method is otherwise equivalent to the timeout method except that it tweaks the moment at when the timeout elapsed to being specified with an absolute value rather than a relative one. For more documentation see the timeout method.

Examples

use futures::prelude::*;
use runtime::prelude::*;
use std::time::{Duration, Instant};

#[runtime::main]
async fn main() {
    let future = long_future();
    let at = Instant::now() + Duration::from_millis(100);
    let timed_out = future.timeout_at(at);

    match timed_out.await {
        Ok(item) => println!("got {:?} within enough time!", item),
        Err(_) => println!("took too long to produce the item"),
    }
}
Loading content...

Implementors

impl<T: Future + Unpin> FutureExt for T[src]

ⓘImportant traits for Timeout<F>
fn timeout(self, dur: Duration) -> Timeout<Self>[src]

ⓘImportant traits for Timeout<F>
fn timeout_at(self, at: Instant) -> Timeout<Self>[src]

Loading content...