Struct ServiceChainFactory 

pub struct ServiceChainFactory<Sf, St, Req> { /* private fields */ }

A builder for composing service factories and combinators.

Implementations

impl<Sf: ServiceFactory<St, Req>, St, Req> ServiceChainFactory<Sf, St, Req>

pub fn and_then<U>( self, factory: impl IntoServiceFactory<U, St, Sf::Res>, ) -> ServiceChainFactory<AndThenFactory<Sf, U>, St, Req>

where Self: Sized, U: ServiceFactory<St, Sf::Res, Error = Sf::Error, InitError = Sf::InitError>,

Chains another factory after this factory’s services.

Each created service passes its response to the next service as its request. If the first service returns an error, the next service is not called.

pub fn apply<U>( self, tr: U, ) -> ServiceChainFactory<ApplyMiddleware<U, Sf>, St, Req>

where U: Middleware<Sf::Service, St>,

Applies middleware to this service factory.

This is shorthand for calling crate::apply on the chained factory.

pub fn apply_fn<F, In, Out, Err>( self, f: F, ) -> ServiceChainFactory<ApplyFactory<F, Sf, St, Req, In, Out, Err>, St, In>

where F: AsyncFn(In, &ApplyCtx<'_, Sf::Service, St, Req>) -> Result<Out, Err> + Clone, Err: From<Sf::Error>,

Applies an asynchronous function as middleware to this service factory.

This is shorthand for calling crate::apply_fn_factory on the chained factory.

pub fn then<F, U>( self, factory: F, ) -> ServiceChainFactory<ThenFactory<Sf, U>, St, Req>

where Self: Sized, F: IntoServiceFactory<U, St, Result<Sf::Res, Sf::Error>>, U: ServiceFactory<St, Result<Sf::Res, Sf::Error>, Error = Sf::Error, InitError = Sf::InitError>,

Chains a factory whose services receive the preceding service’s complete Result.

pub fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<F, Sf, Res>, St, Req>

where Self: Sized, F: Fn(Sf::Res) -> Res + Clone,

Maps responses produced by this factory’s services.

pub fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<F, Sf, E>, St, Req>

where Self: Sized, F: Fn(Sf::Error) -> E + Clone,

Maps errors produced by this factory’s services.

pub fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<F, Sf, E>, St, Req>

where Self: Sized, F: Fn(Sf::InitError) -> E + Clone,

Maps this factory’s initialization error.

pub fn readiness<F>( self, ready: F, ) -> ServiceChainFactory<AndThenFactory<Sf, FnReadiness<F, Sf::Error>>, St, Req>

where Self: Sized, F: AsyncFn(&St) -> Result<(), Sf::Error> + Clone,

Adds a custom readiness check to each created service.

The check runs after the wrapped service’s own readiness check succeeds; the service is ready only when both are ready.

pub fn shutdown<F>( self, sh: F, ) -> ServiceChainFactory<AndThenFactory<Sf, FnShutdown<F, Sf::Error>>, St, Req>

where Self: Sized, F: AsyncFnOnce(&St) + Clone,

Adds a shutdown callback to each created service.

pub async fn pipeline( &self, st: St, ) -> Result<Pipeline<Req, Sf::Res, Sf::Error>, Sf::InitError>

where Sf: 'static, St: 'static, Req: 'static,

Creates a service and wraps it with its state in a Pipeline.

Trait Implementations

impl<Sf, St, Req> Clone for ServiceChainFactory<Sf, St, Req>

where Sf: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Sf, St, Req> Debug for ServiceChainFactory<Sf, St, Req>

where Sf: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Sf: ServiceFactory<St, Req>, St, Req> ServiceFactory<St, Req> for ServiceChainFactory<Sf, St, Req>

type Res = <Sf as ServiceFactory<St, Req>>::Res

Response produced by the created services.

type Error = <Sf as ServiceFactory<St, Req>>::Error

Error produced by the created services.

type Service = <Sf as ServiceFactory<St, Req>>::Service

The type of Service produced by this factory.

type InitError = <Sf as ServiceFactory<St, Req>>::InitError

Error that can occur while constructing a service.

async fn create(&self, st: &St) -> Result<Sf::Service, Sf::InitError>

Asynchronously creates a service using the supplied state.

async fn pipeline( &self, st: St, ) -> Result<Pipeline<Req, Self::Res, Self::Error>, Self::InitError>

where Self: 'static, St: 'static, Req: 'static,

Creates a service and wraps it with its state in a Pipeline.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<F, Self, Res>, St, Req>

where Self: Sized, F: Fn(Self::Res) -> Res + Clone,

Returns a factory whose services map responses to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<F, Self, E>, St, Req>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Returns a factory whose services map errors to a different type.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<F, Self, E>, St, Req>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn and_then<U, F>( self, f: F, ) -> ServiceChainFactory<AndThenFactory<Self, U>, St, Req>

where Self: Sized, U: ServiceFactory<St, Self::Res, Error = Self::Error, InitError = Self::InitError>, F: IntoServiceFactory<U, St, Self::Res>,

Chains another factory after this factory’s services.

fn boxed( self, ) -> BoxServiceFactory<St, Req, Self::Res, Self::Error, Self::InitError>

where St: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.