Trait finchers::Task

pub trait Task {
    type Item;
    type Error;
    type Future: Future<Item = Self::Item, Error = Self::Error>;
    fn launch(self, ctx: &mut TaskContext) -> Self::Future;
}

Abstruction of a Task, returned from an Endpoint.

This trait is an generalization of IntoFuture, extended to allow access to the instance of context at construction a Future.

Associated Types

type Item

The type on success.

type Error

The type on failure.

type Future: Future<Item = Self::Item, Error = Self::Error>

The type of value returned from launch.

Required Methods

fn launch(self, ctx: &mut TaskContext) -> Self::Future

Launches itself and construct a Future, and then return it.

This method will be called after the routing is completed.

Implementors

• impl<T, F, R> Task for AndThen<T, F> where
    T: Task,
    F: Fn(T::Item) -> R,
    R: IntoFuture<Error = T::Error>,  type Item = R::Item; type Error = R::Error; type Future = AndThenFuture<T::Future, F, R>;
• impl<T, E> Task for Body<T, E> where
    T: FromBody,
    E: From<HttpError> + From<T::Error>,  type Item = T; type Error = E; type Future = BodyFuture<T, E>;
• impl<T, F> Task for Inspect<T, F> where
    T: Task,
    F: Fn(&T::Item),  type Item = T::Item; type Error = T::Error; type Future = InspectFuture<T::Future, F>;
• impl<T1, T2, E> Task for Join<T1, T2> where
    T1: Task<Error = E>,
    T2: Task<Error = E>,  type Item = (T1::Item, T2::Item); type Error = E; type Future = Join<T1::Future, T2::Future>;
• impl<T1, T2, T3, E> Task for Join3<T1, T2, T3> where
    T1: Task<Error = E>,
    T2: Task<Error = E>,
    T3: Task<Error = E>,  type Item = (T1::Item, T2::Item, T3::Item); type Error = E; type Future = Join3<T1::Future, T2::Future, T3::Future>;
• impl<T1, T2, T3, T4, E> Task for Join4<T1, T2, T3, T4> where
    T1: Task<Error = E>,
    T2: Task<Error = E>,
    T3: Task<Error = E>,
    T4: Task<Error = E>,  type Item = (T1::Item, T2::Item, T3::Item, T4::Item); type Error = E; type Future = Join4<T1::Future, T2::Future, T3::Future, T4::Future>;
• impl<T1, T2, T3, T4, T5, E> Task for Join5<T1, T2, T3, T4, T5> where
    T1: Task<Error = E>,
    T2: Task<Error = E>,
    T3: Task<Error = E>,
    T4: Task<Error = E>,
    T5: Task<Error = E>,  type Item = (T1::Item, T2::Item, T3::Item, T4::Item, T5::Item); type Error = E; type Future = Join5<T1::Future, T2::Future, T3::Future, T4::Future, T5::Future>;
• impl<T> Task for JoinAll<T> where
    T: Task,  type Item = Vec<T::Item>; type Error = T::Error; type Future = JoinAll<Vec<T::Future>>;
• impl<T, F, R> Task for MapErr<T, F> where
    T: Task,
    F: Fn(T::Error) -> R,  type Item = T::Item; type Error = R; type Future = MapErrFuture<T::Future, F>;
• impl<T, F, R> Task for Map<T, F> where
    T: Task,
    F: Fn(T::Item) -> R,  type Item = R; type Error = T::Error; type Future = MapFuture<T::Future, F>;
• impl<T1, T2> Task for Or<T1, T2> where
    T1: Task,
    T2: Task<Item = T1::Item, Error = T1::Error>,  type Item = T1::Item; type Error = T1::Error; type Future = OrFuture<T1::Future, T2::Future>;
• impl<T, F, R> Task for OrElse<T, F> where
    T: Task,
    F: Fn(T::Error) -> R,
    R: IntoFuture<Item = T::Item>,  type Item = R::Item; type Error = R::Error; type Future = OrElseFuture<T::Future, F, R>;
• impl<F: IntoFuture> Task for F type Item = F::Item; type Error = F::Error; type Future = F::Future;
• impl<T, F, R> Task for Then<T, F> where
    T: Task,
    F: Fn(Result<T::Item, T::Error>) -> R,
    R: IntoFuture,  type Item = R::Item; type Error = R::Error; type Future = ThenFuture<T::Future, F, R>;