Skip to main content

ServiceChainFactory

Struct ServiceChainFactory 

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

A builder for composing service factories and combinators.

Created by factory() and factory combinators. Builder methods consume the chain and configure how future services are constructed; they do not create services immediately.

The chain implements ServiceFactory by forwarding creation to its enclosed factory. Self::pipeline additionally stores the supplied state with the created service and binds it for readiness notifications.

Self::map_err transforms call and readiness errors from created services, while Self::map_init_err transforms construction errors. Self::apply installs a Middleware wrapper on each created service.

Cloning clones the enclosed factory without creating a service. Whether the clones share factory state depends on the enclosed implementation.

Implementations§

Source§

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

Source

pub fn and_then<U>( self, factory: impl IntoServiceFactory<U, St, <Sf as ServiceFactory<St, Req>>::Res>, ) -> ServiceChainFactory<AndThenFactory<Sf, U>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, U: ServiceFactory<St, <Sf as ServiceFactory<St, Req>>::Res, Error = <Sf as ServiceFactory<St, Req>>::Error, InitError = <Sf as ServiceFactory<St, Req>>::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.

Factories use the same state, service-error, and initialization-error types. They are created sequentially with the same state reference; a first-factory error prevents creation of the second service. Initialization errors are returned unchanged. See AndThenFactory.

Source

pub fn apply<U>( self, tr: U, ) -> ServiceChainFactory<ApplyMiddleware<U, Sf>, St, Req>
where U: Middleware<<Sf as ServiceFactory<St, Req>>::Service, St>,

Applies middleware to this service factory.

This is shorthand for calling crate::apply on the chained factory. The inner factory creates a service first, then the middleware wraps it synchronously with the same state reference. Initialization errors bypass the middleware.

For the result to implement ServiceFactory, the middleware’s service must accept the same state and request types. It may change response and service-error types.

Source

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 as ServiceFactory<St, Req>>::Service, St, Req>) -> Result<Out, Err> + Clone, Err: From<<Sf as ServiceFactory<St, Req>>::Error>,

Applies an asynchronous function as middleware to this service factory.

This is shorthand for calling crate::apply_fn_factory on the chained factory. Each successful creation wraps the service with a clone of the function, which receives an input request and an ApplyCtx.

Request, response, and service-error types may change; state and initialization errors remain unchanged. See crate::apply_fn for lifecycle forwarding and readiness semantics.

Source

pub fn then<F, U>( self, factory: F, ) -> ServiceChainFactory<ThenFactory<Sf, U>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, F: IntoServiceFactory<U, St, Result<<Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>>, U: ServiceFactory<St, Result<<Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>, Error = <Sf as ServiceFactory<St, Req>>::Error, InitError = <Sf as ServiceFactory<St, Req>>::InitError>,

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

The second service can recover from a failed first call or transform a successful response. Both services use the same state and error types. Errors from the chain’s readiness check are returned directly, rather than passed to the second service.

Factories must also share their initialization-error type. Creation is sequential with the same state reference, and an initialization error stops construction rather than being passed to the next factory. See ThenFactory for an example.

Source

pub fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<F, Sf, Res>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, F: Fn(<Sf as ServiceFactory<St, Req>>::Res) -> Res + Clone,

Maps responses produced by this factory’s services.

Each successful creation clones the synchronous mapping function into the new service. The function runs only on successful responses, not during initialization. Request, state, service-error, and initialization-error types are unchanged. See MapFactory.

Source

pub fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<F, Sf, E>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, F: Fn(<Sf as ServiceFactory<St, Req>>::Error) -> E + Clone,

Maps errors produced by this factory’s services.

Each successful creation clones the synchronous mapping function into the new service. It transforms call and readiness errors, leaving successful responses unchanged. Initialization errors are not mapped; use Self::map_init_err for those. See MapErrFactory.

Source

pub fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<F, Sf, E>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, F: Fn(<Sf as ServiceFactory<St, Req>>::InitError) -> E + Clone,

Maps this factory’s initialization error.

The synchronous function runs only when creating the inner service fails. Successful services are returned unchanged, including their call and readiness error types. Use Self::map_err to map those.

Source

pub fn readiness<F>( self, ready: F, ) -> ServiceChainFactory<AndThenFactory<Sf, FnReadiness<F, <Sf as ServiceFactory<St, Req>>::Error>>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, F: AsyncFn(&St) -> Result<(), <Sf as ServiceFactory<St, Req>>::Error> + Clone,

Adds a custom readiness check to each created service.

Each created service gets a clone of the callback. Its readiness future is polled alongside the wrapped service’s readiness future; the service is ready only when both succeed. Requests and responses are unchanged.

The inner factory must have std::convert::Infallible initialization errors for this composition to implement ServiceFactory. Successful readiness can be cached, so the callback need not run for every request.

The callback receives only pipeline state. For scoped readiness and change notifications, implement Service directly.

Source

pub fn shutdown<F>( self, sh: F, ) -> ServiceChainFactory<AndThenFactory<Sf, FnShutdown<F, <Sf as ServiceFactory<St, Req>>::Error>>, St, Req>
where ServiceChainFactory<Sf, St, Req>: Sized, F: AsyncFnOnce(&St) + Clone,

Adds a shutdown callback to each created service.

Each service gets its own callback, invoked at most once with pipeline state. It is polled alongside the inner service’s shutdown, and shutdown waits for both. Cancellation does not restore a consumed callback; dropping a service alone does not invoke it.

The inner factory must have std::convert::Infallible initialization errors for this composition to implement ServiceFactory.

Source

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

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

The factory first borrows st for creation, then the pipeline takes ownership of both state and service and binds readiness notifications. Creation errors are returned unchanged.

This does not wait for service readiness. Use Pipeline::ready to check it explicitly; Pipeline::call checks it before dispatch. Each invocation creates a new service and enclosing pipeline readiness scope, subject to any sharing introduced by the inner factory.

Trait Implementations§

Source§

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

Source§

fn clone(&self) -> ServiceChainFactory<Sf, St, Req>

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

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

Response produced by the created services.
Source§

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

Error produced by the created services.
Source§

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

The type of Service produced by this factory.
Source§

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

Error that can occur while constructing a service.
Source§

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

Asynchronously creates a service using the supplied state.
Source§

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.
Source§

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.
Source§

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.
Source§

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.
Source§

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. Read more
Source§

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.

Auto Trait Implementations§

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

Source§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

Source§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

Source§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

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

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<Sf, St, Req> IntoServiceFactory<Sf, St, Req> for Sf
where Sf: ServiceFactory<St, Req>,

Source§

fn into_factory(self) -> Sf

Converts this value into a service factory.
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

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

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V