Struct ntex_service::PipelineFactory

pub struct PipelineFactory<T, R, C = ()> { /* fields omitted */ }

Pipeline factory

Implementations

impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C>

pub fn and_then<F, U>(
    self,
    factory: F
) -> PipelineFactory<AndThenFactory<T, U, R, C>, R, C> where
    Self: Sized,
    C: Clone,
    F: IntoServiceFactory<U, T::Response, C>,
    U: ServiceFactory<T::Response, C, Error = T::Error, InitError = T::InitError>, 

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

pub fn apply<U>(
    self,
    tr: U
) -> PipelineFactory<ApplyTransform<U, T, R, C>, R, C> where
    U: Transform<T::Service>, 

Apply transform to current service factory.

Short version of apply(transform, pipeline_factory(...))

pub fn then<F, U>(
    self,
    factory: F
) -> PipelineFactory<ThenFactory<T, U, R>, R, C> where
    Self: Sized,
    C: Clone,
    F: IntoServiceFactory<U, Result<T::Response, T::Error>, C>,
    U: ServiceFactory<Result<T::Response, T::Error>, C, Error = T::Error, InitError = T::InitError>, 

Create NewService to 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, Res>(
    self,
    f: F
) -> PipelineFactory<MapServiceFactory<T, F, R, Res, C>, R, C> where
    Self: Sized,
    F: FnMut(T::Response) -> Res + Clone, 

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

pub fn map_err<F, E>(
    self,
    f: F
) -> PipelineFactory<MapErrServiceFactory<T, R, C, F, E>, R, C> where
    Self: Sized,
    F: Fn(T::Error) -> E + Clone, 

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

pub fn map_init_err<F, E>(
    self,
    f: F
) -> PipelineFactory<MapInitErr<T, R, C, F, E>, R, C> where
    Self: Sized,
    F: Fn(T::InitError) -> E + Clone, 

Map this factory’s init error to a different error, returning a new service.

Trait Implementations

impl<T, R, C> Clone for PipelineFactory<T, R, C> 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.

impl<T: ServiceFactory<R, C>, R, C> ServiceFactory<R, C> for PipelineFactory<T, R, C>

type Response = T::Response

Responses given by the service

type Error = T::Error

Errors produced by the service

type Service = T::Service

The Service value created by this factory

type InitError = T::InitError

Errors produced while building a service.

type Future = T::Future

The future of the ServiceFactory instance.

fn new_service(&self, cfg: C) -> Self::Future

Create and return a new service value asynchronously.

fn map<F, Res>(self, f: F) -> MapServiceFactory<Self, F, Req, Res, Cfg> where
    Self: Sized,
    F: FnMut(Self::Response) -> Res + Clone, 

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) -> MapErrServiceFactory<Self, Req, Cfg, F, E> where
    Self: Sized,
    F: Fn(Self::Error) -> E + Clone, 

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

fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, Req, Cfg, F, E> where
    Self: Sized,
    F: Fn(Self::InitError) -> E + Clone, 

Map this factory’s init error to a different error, returning a new service.