Struct actix_service::Pipeline

pub struct Pipeline<T> { /* fields omitted */ }

Pipeline service

Methods

impl<T: Service> Pipeline<T>

pub fn and_then<F, U>(self, service: F) -> Pipeline<AndThenService<T, U>> where
    Self: Sized,
    F: IntoService<U>,
    U: Service<Request = T::Response, Error = T::Error>, 

Call another service after call to this one has resolved successfully.

This function can be used to chain two services together and ensure that the second service isn't called until call to the fist service have finished. Result of the call to the first service is used as an input parameter for the second service's call.

Note that this function consumes the receiving service and returns a wrapped version of it.

pub fn then<F, U>(self, service: F) -> Pipeline<ThenService<T, U>> where
    Self: Sized,
    F: IntoService<U>,
    U: Service<Request = Result<T::Response, T::Error>, Error = T::Error>, 

Chain on a computation for when a call to the service finished, passing the result of the call to the next service U.

Note that this function consumes the receiving pipeline and returns a wrapped version of it.

Trait Implementations

impl<T: Service> Service for Pipeline<T>

type Request = T::Request

Requests handled by the service.

type Response = T::Response

Responses given by the service.

type Error = T::Error

Errors produced by the service.

type Future = T::Future

The future response value.

fn poll_ready(&mut self, ctx: &mut Context) -> Poll<Result<(), T::Error>>

Returns Ready when the service is able to process requests.

fn call(&mut self, req: T::Request) -> Self::Future

Process the request and return the response asynchronously.

fn map<F, R>(self, f: F) -> Map<Self, F, R> where
    Self: Sized,
    F: FnMut(Self::Response) -> R, 

Map this service's output to a different type, returning a new service of the resulting type.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E> where
    Self: Sized,
    F: Fn(Self::Error) -> E, 

Map this service's error to a different error, returning a new service.

impl<T> Clone for Pipeline<T> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.