Trait future_utils::FutureExt[−][src]

pub trait FutureExt: Future + Sized {
    fn into_boxed(self) -> BoxFuture<Self::Item, Self::Error>
    where
        Self: 'static,
    { ... }

    fn into_send_boxed(self) -> BoxSendFuture<Self::Item, Self::Error>
    where
        Self: Send + 'static,
    { ... }

    fn until<C>(self, condition: C) -> Until<Self, C>
    where
        C: Future<Item = ()>,
        Self::Error: From<C::Error>,
    { ... }

    fn infallible<E>(self) -> Infallible<Self, E>
    where
        Self: Future<Error = Void>,
    { ... }

    fn log_error(
        self, 
        level: LogLevel, 
        description: &'static str
    ) -> LogError<Self>
    where
        Self: Future<Item = ()>,
        Self::Error: Display,
    { ... }

    fn finally<D>(self, on_drop: D) -> Finally<Self, D>
    where
        D: FnOnce(),
    { ... }

    fn with_timeout(self, duration: Duration) -> WithTimeout<Self> { ... }

    fn with_timeout_at(self, instant: Instant) -> WithTimeout<Self> { ... }

    fn first_ok2<F>(self, other: F) -> FirstOk2<Self, F>
    where
        F: Future<Item = Self::Item>,
    { ... }

    fn while_driving<F: Future>(self, other: F) -> WhileDriving<Self, F> { ... }

    fn resume_unwind(self) -> ResumeUnwind<Self>
    where
        Self: Future<Error = Box<Any + Send + 'static>>,
    { ... }
}

Extension trait for Future.

Provided Methods

Wraps a future into a boxed future, making type-checking easier at the expense of an extra layer of indirection at runtime.

Run this future until some condition is met. If condition resolves before self then None is returned.

Example

let my_future_with_timeout = my_future.until(Delay::new(Instant::now() + Duration::from_secs(1)));

For futures which can't fail (ie. which have error type Void), cast the error type to some inferred type.

Take a future which returns () and log its error if it fails. The returned future cannot fail and will always resolve to ().

Executes the future and runs the provided callback when the future finishes. The callback will also be run if the entire future is dropped.

Runs the future for the given duration, returning its value in an option, or returning None if the timeout expires.

Runs the future until the given instant, returning its value in an option, or returning None if the timeout expires.

Run two futures in parallel and yield the value of the first to return success. If both futures fail, return both errors.

Resolves self while driving other in parallel.

Propogates the result of a .catch_unwind, panicking if the future resolves to an Err

Implementors