[−][src]Struct actix_service::Pipeline
Pipeline service - pipeline allows to compose multiple service into one service.
Implementations
impl<T: Service> Pipeline<T>
[src]
pub fn and_then<F, U>(
self,
service: F
) -> Pipeline<impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone> where
Self: Sized,
F: IntoService<U>,
U: Service<Request = T::Response, Error = T::Error>,
[src]
self,
service: F
) -> Pipeline<impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone> 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 and_then_apply_fn<U, I, F, Fut, Res, Err>(
self,
service: I,
f: F
) -> Pipeline<impl Service<Request = T::Request, Response = Res, Error = Err> + Clone> where
Self: Sized,
I: IntoService<U>,
U: Service,
F: FnMut(T::Response, &mut U) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<T::Error> + From<U::Error>,
[src]
self,
service: I,
f: F
) -> Pipeline<impl Service<Request = T::Request, Response = Res, Error = Err> + Clone> where
Self: Sized,
I: IntoService<U>,
U: Service,
F: FnMut(T::Response, &mut U) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<T::Error> + From<U::Error>,
Apply function to specified service and use it as a next service in chain.
Short version of pipeline_factory(...).and_then(apply_fn_factory(...))
pub fn then<F, U>(
self,
service: F
) -> Pipeline<impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone> where
Self: Sized,
F: IntoService<U>,
U: Service<Request = Result<T::Response, T::Error>, Error = T::Error>,
[src]
self,
service: F
) -> Pipeline<impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone> 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.
pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, R>> where
Self: Sized,
F: FnMut(T::Response) -> R,
[src]
Self: Sized,
F: FnMut(T::Response) -> R,
Map this service's output to a different type, returning a new service of the resulting type.
This function is similar to the Option::map
or Iterator::map
where
it will change the type of the underlying service.
Note that this function consumes the receiving service and returns a
wrapped version of it, similar to the existing map
methods in the
standard library.
pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>> where
Self: Sized,
F: Fn(T::Error) -> E,
[src]
Self: Sized,
F: Fn(T::Error) -> E,
Map this service's error to a different error, returning a new service.
This function is similar to the Result::map_err
where it will change
the error type of the underlying service. This is useful for example to
ensure that services have the same error type.
Note that this function consumes the receiving service and returns a wrapped version of it.
Trait Implementations
impl<T> Clone for Pipeline<T> where
T: Clone,
[src]
T: Clone,
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Service> Service for Pipeline<T>
[src]
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>>
[src]
fn call(&mut self, req: T::Request) -> Self::Future
[src]
fn map<F, R>(self, f: F) -> Map<Self, F, R> where
Self: Sized,
F: FnMut(Self::Response) -> R,
[src]
Self: Sized,
F: FnMut(Self::Response) -> R,
fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E> where
Self: Sized,
F: Fn(Self::Error) -> E,
[src]
Self: Sized,
F: Fn(Self::Error) -> E,
Auto Trait Implementations
impl<T> RefUnwindSafe for Pipeline<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Pipeline<T> where
T: Send,
T: Send,
impl<T> Sync for Pipeline<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Pipeline<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Pipeline<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IntoService<T> for T where
T: Service,
[src]
T: Service,
fn into_service(Self) -> T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,