Trait ntex::ServiceFactory

source ·
pub trait ServiceFactory<Req, Cfg = ()> {
    type Response;
    type Error;
    type Service: Service<Req, Response = Self::Response, Error = Self::Error>;
    type InitError;
    type Future<'f>: Future<Output = Result<Self::Service, Self::InitError>>
       where Cfg: 'f,
             Self: 'f;

    // Required method
    fn create(&self, cfg: Cfg) -> Self::Future<'_>;

    // Provided methods
    fn pipeline(&self, cfg: Cfg) -> CreatePipeline<'_, Self, Req, Cfg> 
       where Self: Sized { ... }
    fn map<F, Res>(
        self,
        f: F
    ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>
       where Self: Sized,
             F: Fn(Self::Response) -> Res + Clone { ... }
    fn map_err<F, E>(
        self,
        f: F
    ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>
       where Self: Sized,
             F: Fn(Self::Error) -> E + Clone { ... }
    fn map_init_err<F, E>(
        self,
        f: F
    ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>
       where Self: Sized,
             F: Fn(Self::InitError) -> E + Clone { ... }
}
Expand description

Factory for creating Services.

This is useful for cases where new Services must be produced. One case is a TCP server listener: a listener accepts new connections, constructs a new Service for each using the ServiceFactory trait, and uses the new Service to process inbound requests on that new connection.

Config is a service factory configuration type.

Simple factories may be able to use fn_factory or fn_factory_with_config to reduce boilerplate.

Required Associated Types§

source

type Response

Responses given by the created services.

source

type Error

Errors produced by the created services.

source

type Service: Service<Req, Response = Self::Response, Error = Self::Error>

The kind of Service created by this factory.

source

type InitError

Errors potentially raised while building a service.

source

type Future<'f>: Future<Output = Result<Self::Service, Self::InitError>> where Cfg: 'f, Self: 'f

The future of the ServiceFactory instance.

Required Methods§

source

fn create(&self, cfg: Cfg) -> Self::Future<'_>

Create and return a new service value asynchronously.

Provided Methods§

source

fn pipeline(&self, cfg: Cfg) -> CreatePipeline<'_, Self, Req, Cfg>
where Self: Sized,

Create and return a new service value asynchronously and wrap into a container

source

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

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

source

fn map_err<F, E>( self, f: F ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>
where Self: Sized, F: Fn(Self::Error) -> E + Clone,

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

source

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

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

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl<Ctl, Pub> ServiceFactory<IoBoxed> for Server<Ctl, Pub>

§

type Response = ()

§

type Error = ServerError<()>

§

type Service = ServerHandler<Ctl, Pub>

§

type InitError = ()

§

type Future<'f> = Ready<<Server<Ctl, Pub> as ServiceFactory<IoBoxed>>::Service, <Server<Ctl, Pub> as ServiceFactory<IoBoxed>>::InitError>

source§

fn create( &self, _: () ) -> <Server<Ctl, Pub> as ServiceFactory<IoBoxed>>::Future<'_>

source§

impl<F, Ctl, Pub> ServiceFactory<Io<F>> for Server<Ctl, Pub>

§

type Response = ()

§

type Error = ServerError<()>

§

type Service = ServerHandler<Ctl, Pub>

§

type InitError = ()

§

type Future<'f> = Ready<<Server<Ctl, Pub> as ServiceFactory<Io<F>>>::Service, <Server<Ctl, Pub> as ServiceFactory<Io<F>>>::InitError>

source§

fn create( &self, _: () ) -> <Server<Ctl, Pub> as ServiceFactory<Io<F>>>::Future<'_>

source§

impl<S, Req, Cfg> ServiceFactory<Req, Cfg> for Rc<S>
where S: ServiceFactory<Req, Cfg>,

§

type Response = <S as ServiceFactory<Req, Cfg>>::Response

§

type Error = <S as ServiceFactory<Req, Cfg>>::Error

§

type Service = <S as ServiceFactory<Req, Cfg>>::Service

§

type InitError = <S as ServiceFactory<Req, Cfg>>::InitError

§

type Future<'f> = <S as ServiceFactory<Req, Cfg>>::Future<'f> where S: 'f, Cfg: 'f

source§

fn create(&self, cfg: Cfg) -> <S as ServiceFactory<Req, Cfg>>::Future<'_>

Implementors§

source§

impl ServiceFactory<Request> for ExpectHandler

source§

impl<A, B, R, C> ServiceFactory<R, C> for ThenFactory<A, B>
where A: ServiceFactory<R, C>, B: ServiceFactory<Result<<A as ServiceFactory<R, C>>::Response, <A as ServiceFactory<R, C>>::Error>, C, Error = <A as ServiceFactory<R, C>>::Error, InitError = <A as ServiceFactory<R, C>>::InitError>, C: Clone,

§

type Response = <B as ServiceFactory<Result<<A as ServiceFactory<R, C>>::Response, <A as ServiceFactory<R, C>>::Error>, C>>::Response

§

type Error = <A as ServiceFactory<R, C>>::Error

§

type Service = Then<<A as ServiceFactory<R, C>>::Service, <B as ServiceFactory<Result<<A as ServiceFactory<R, C>>::Response, <A as ServiceFactory<R, C>>::Error>, C>>::Service>

§

type InitError = <A as ServiceFactory<R, C>>::InitError

§

type Future<'f> = ThenFactoryResponse<'f, A, B, R, C> where ThenFactory<A, B>: 'f, C: 'f

source§

impl<A, B, Req, Cfg> ServiceFactory<Req, Cfg> for AndThenFactory<A, B>
where A: ServiceFactory<Req, Cfg>, B: ServiceFactory<<A as ServiceFactory<Req, Cfg>>::Response, Cfg, Error = <A as ServiceFactory<Req, Cfg>>::Error, InitError = <A as ServiceFactory<Req, Cfg>>::InitError>, Cfg: Clone,

§

type Response = <B as ServiceFactory<<A as ServiceFactory<Req, Cfg>>::Response, Cfg>>::Response

§

type Error = <A as ServiceFactory<Req, Cfg>>::Error

§

type Service = AndThen<<A as ServiceFactory<Req, Cfg>>::Service, <B as ServiceFactory<<A as ServiceFactory<Req, Cfg>>::Response, Cfg>>::Service>

§

type InitError = <A as ServiceFactory<Req, Cfg>>::InitError

§

type Future<'f> = AndThenFactoryResponse<'f, A, B, Req, Cfg> where AndThenFactory<A, B>: 'f, Cfg: 'f

source§

impl<A, F, R, C, C2> ServiceFactory<R, C> for MapConfig<A, F, C, C2>
where A: ServiceFactory<R, C2>, F: Fn(C) -> C2,

§

type Response = <A as ServiceFactory<R, C2>>::Response

§

type Error = <A as ServiceFactory<R, C2>>::Error

§

type Service = <A as ServiceFactory<R, C2>>::Service

§

type InitError = <A as ServiceFactory<R, C2>>::InitError

§

type Future<'f> = <A as ServiceFactory<R, C2>>::Future<'f> where MapConfig<A, F, C, C2>: 'f

source§

impl<A, F, Req, Res, Cfg> ServiceFactory<Req, Cfg> for MapFactory<A, F, Req, Res, Cfg>
where A: ServiceFactory<Req, Cfg>, F: Fn(<A as ServiceFactory<Req, Cfg>>::Response) -> Res + Clone,

§

type Response = Res

§

type Error = <A as ServiceFactory<Req, Cfg>>::Error

§

type Service = Map<<A as ServiceFactory<Req, Cfg>>::Service, F, Req, Res>

§

type InitError = <A as ServiceFactory<Req, Cfg>>::InitError

§

type Future<'f> = MapFactoryFuture<'f, A, F, Req, Res, Cfg> where MapFactory<A, F, Req, Res, Cfg>: 'f, Cfg: 'f

source§

impl<A, R, C> ServiceFactory<R, C> for UnitConfig<A>
where A: ServiceFactory<R>,

§

type Response = <A as ServiceFactory<R>>::Response

§

type Error = <A as ServiceFactory<R>>::Error

§

type Service = <A as ServiceFactory<R>>::Service

§

type InitError = <A as ServiceFactory<R>>::InitError

§

type Future<'f> = UnitConfigFuture<'f, A, R, C> where UnitConfig<A>: 'f, C: 'f

source§

impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrFactory<A, R, C, F, E>
where A: ServiceFactory<R, C>, F: Fn(<A as ServiceFactory<R, C>>::Error) -> E + Clone,

§

type Response = <A as ServiceFactory<R, C>>::Response

§

type Error = E

§

type Service = MapErr<<A as ServiceFactory<R, C>>::Service, F, E>

§

type InitError = <A as ServiceFactory<R, C>>::InitError

§

type Future<'f> = MapErrFactoryFuture<'f, A, R, C, F, E> where MapErrFactory<A, R, C, F, E>: 'f, C: 'f

source§

impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
where A: ServiceFactory<R, C>, F: Fn(<A as ServiceFactory<R, C>>::InitError) -> E + Clone,

§

type Response = <A as ServiceFactory<R, C>>::Response

§

type Error = <A as ServiceFactory<R, C>>::Error

§

type Service = <A as ServiceFactory<R, C>>::Service

§

type InitError = E

§

type Future<'f> = MapInitErrFuture<'f, A, R, C, F, E> where MapInitErr<A, R, C, F, E>: 'f, C: 'f

source§

impl<C, Req, Res, Err, InitErr> ServiceFactory<Req, C> for BoxServiceFactory<C, Req, Res, Err, InitErr>
where Req: 'static,

§

type Response = Res

§

type Error = Err

§

type Service = BoxService<Req, Res, Err>

§

type InitError = InitErr

§

type Future<'f> = Pin<Box<dyn Future<Output = Result<<BoxServiceFactory<C, Req, Res, Err, InitErr> as ServiceFactory<Req, C>>::Service, InitErr>> + 'f>> where BoxServiceFactory<C, Req, Res, Err, InitErr>: 'f, C: 'f

source§

impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err>

§

type Response = WebResponse

§

type Error = <Err as ErrorRenderer>::Container

§

type InitError = ()

§

type Service = RouteService<Err>

§

type Future<'f> = Ready<RouteService<Err>, ()>

source§

impl<F> ServiceFactory<(Request, Io<F>, Codec)> for UpgradeHandler<F>

source§

impl<F, C> ServiceFactory<Io<F>, C> for ntex::tls::openssl::Acceptor<F>
where F: Filter, C: 'static,

source§

impl<F, C> ServiceFactory<Io<F>, C> for ntex::tls::rustls::Acceptor<F>
where F: Filter, C: 'static,

§

type Response = Io<Layer<TlsFilter, F>>

§

type Error = Error

§

type Service = AcceptorService<F>

§

type InitError = ()

§

type Future<'f> = Ready<<Acceptor<F> as ServiceFactory<Io<F>, C>>::Service, <Acceptor<F> as ServiceFactory<Io<F>, C>>::InitError> where Acceptor<F>: 'f, C: 'f

source§

impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req, Cfg> for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
where F: Fn(Cfg) -> Fut, Fut: Future<Output = Result<Srv, Err>>, Srv: Service<Req>,

§

type Response = <Srv as Service<Req>>::Response

§

type Error = <Srv as Service<Req>>::Error

§

type Service = Srv

§

type InitError = Err

§

type Future<'f> = Fut where FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>: 'f, Fut: 'f

source§

impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory<Req, Cfg> for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where F: Fn(Req) -> Fut + Clone, Fut: Future<Output = Result<Res, Err>>,

§

type Response = Res

§

type Error = Err

§

type Service = FnService<F, Req>

§

type InitError = ()

§

type Future<'f> = Ready<Result<<FnServiceFactory<F, Fut, Req, Res, Err, Cfg> as ServiceFactory<Req, Cfg>>::Service, <FnServiceFactory<F, Fut, Req, Res, Err, Cfg> as ServiceFactory<Req, Cfg>>::InitError>> where FnServiceFactory<F, Fut, Req, Res, Err, Cfg>: 'f

source§

impl<F, S, B> ServiceFactory<Io<F>> for H2Service<F, S, B>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, B: MessageBody,

§

type Response = ()

§

type Error = DispatchError

§

type InitError = <S as ServiceFactory<Request>>::InitError

§

type Service = H2ServiceHandler<F, <S as ServiceFactory<Request>>::Service, B>

§

type Future<'f> = Pin<Box<dyn Future<Output = Result<<H2Service<F, S, B> as ServiceFactory<Io<F>>>::Service, <H2Service<F, S, B> as ServiceFactory<Io<F>>>::InitError>> + 'f>>

source§

impl<F, S, B, X, U> ServiceFactory<Io<F>> for H1Service<F, S, B, X, U>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, X: ServiceFactory<Request, Response = Request> + 'static, X::Error: ResponseError, X::InitError: Debug, U: ServiceFactory<(Request, Io<F>, Codec), Response = ()> + 'static, U::Error: Display + Error, U::InitError: Debug,

§

type Response = ()

§

type Error = DispatchError

§

type InitError = ()

§

type Service = H1ServiceHandler<F, <S as ServiceFactory<Request>>::Service, B, <X as ServiceFactory<Request>>::Service, <U as ServiceFactory<(Request, Io<F>, Codec)>>::Service>

§

type Future<'f> = Pin<Box<dyn Future<Output = Result<<H1Service<F, S, B, X, U> as ServiceFactory<Io<F>>>::Service, <H1Service<F, S, B, X, U> as ServiceFactory<Io<F>>>::InitError>> + 'f>>

source§

impl<F, S, B, X, U> ServiceFactory<Io<F>> for HttpService<F, S, B, X, U>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, X: ServiceFactory<Request, Response = Request> + 'static, X::Error: ResponseError, X::InitError: Debug, U: ServiceFactory<(Request, Io<F>, Codec), Response = ()> + 'static, U::Error: Display + Error, U::InitError: Debug,

§

type Response = ()

§

type Error = DispatchError

§

type InitError = ()

§

type Service = HttpServiceHandler<F, <S as ServiceFactory<Request>>::Service, B, <X as ServiceFactory<Request>>::Service, <U as ServiceFactory<(Request, Io<F>, Codec)>>::Service>

§

type Future<'f> = Pin<Box<dyn Future<Output = Result<<HttpService<F, S, B, X, U> as ServiceFactory<Io<F>>>::Service, <HttpService<F, S, B, X, U> as ServiceFactory<Io<F>>>::InitError>> + 'f>>

source§

impl<F, S, R, Req, E, C> ServiceFactory<Req, C> for FnServiceNoConfig<F, S, R, Req, E>
where F: Fn() -> R, R: Future<Output = Result<S, E>>, S: Service<Req>, C: 'static,

§

type Response = <S as Service<Req>>::Response

§

type Error = <S as Service<Req>>::Error

§

type Service = S

§

type InitError = E

§

type Future<'f> = R where FnServiceNoConfig<F, S, R, Req, E>: 'f, R: 'f

source§

impl<R, E, F, C> ServiceFactory<R, C> for KeepAlive<R, E, F>
where C: 'static, F: Fn() -> E + Clone,

§

type Response = R

§

type Error = E

§

type InitError = Infallible

§

type Service = KeepAliveService<R, E, F>

§

type Future<'f> = Ready<<KeepAlive<R, E, F> as ServiceFactory<R, C>>::Service, <KeepAlive<R, E, F> as ServiceFactory<R, C>>::InitError> where KeepAlive<R, E, F>: 'f, C: 'f

source§

impl<T, C> ServiceFactory<Connect<T>, C> for ntex::connect::openssl::Connector<T>
where T: Address, C: 'static,

source§

impl<T, C> ServiceFactory<Connect<T>, C> for ntex::connect::rustls::Connector<T>
where T: Address, C: 'static,

source§

impl<T, C> ServiceFactory<Connect<T>, C> for ntex::connect::Connector<T>
where T: Address, C: 'static,

source§

impl<T, C> ServiceFactory<Connect<T>, C> for Resolver<T>
where T: Address, C: 'static,

source§

impl<T, R, C> ServiceFactory<R, C> for ServiceChainFactory<T, R, C>
where T: ServiceFactory<R, C>,

§

type Response = <T as ServiceFactory<R, C>>::Response

§

type Error = <T as ServiceFactory<R, C>>::Error

§

type Service = <T as ServiceFactory<R, C>>::Service

§

type InitError = <T as ServiceFactory<R, C>>::InitError

§

type Future<'f> = <T as ServiceFactory<R, C>>::Future<'f> where ServiceChainFactory<T, R, C>: 'f

source§

impl<T, Req, Cfg, F, R, In, Out, Err> ServiceFactory<In, Cfg> for ApplyFactory<T, Req, Cfg, F, R, In, Out, Err>
where T: ServiceFactory<Req, Cfg>, F: Fn(In, Pipeline<<T as ServiceFactory<Req, Cfg>>::Service>) -> R + Clone, R: Future<Output = Result<Out, Err>>, Err: From<<T as ServiceFactory<Req, Cfg>>::Error>,

§

type Response = Out

§

type Error = Err

§

type Service = Apply<<T as ServiceFactory<Req, Cfg>>::Service, Req, F, R, In, Out, Err>

§

type InitError = <T as ServiceFactory<Req, Cfg>>::InitError

§

type Future<'f> = ApplyFactoryResponse<'f, T, Req, Cfg, F, R, In, Out, Err> where ApplyFactory<T, Req, Cfg, F, R, In, Out, Err>: 'f, Cfg: 'f

source§

impl<T, S, R, C> ServiceFactory<R, C> for ApplyMiddleware<T, S, C>
where S: ServiceFactory<R, C>, T: Middleware<<S as ServiceFactory<R, C>>::Service>, <T as Middleware<<S as ServiceFactory<R, C>>::Service>>::Service: Service<R>,

§

type Response = <<T as Middleware<<S as ServiceFactory<R, C>>::Service>>::Service as Service<R>>::Response

§

type Error = <<T as Middleware<<S as ServiceFactory<R, C>>::Service>>::Service as Service<R>>::Error

§

type Service = <T as Middleware<<S as ServiceFactory<R, C>>::Service>>::Service

§

type InitError = <S as ServiceFactory<R, C>>::InitError

§

type Future<'f> = ApplyMiddlewareFuture<'f, T, S, R, C> where ApplyMiddleware<T, S, C>: 'f, C: 'f

source§

impl<V1, V1C, V2, V1R, V2R> ServiceFactory<Variant2<V1R, V2R>, V1C> for VariantFactory2<V1, V1C, V2, V1R, V2R>
where V1: ServiceFactory<V1R, V1C>, V1C: Clone, V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService2<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, V1R, V2R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V1R, V2R> where VariantFactory2<V1, V1C, V2, V1R, V2R>: 'f, V1C: 'f

source§

impl<V1, V1C, V2, V3, V1R, V2R, V3R> ServiceFactory<Variant3<V1R, V2R, V3R>, V1C> for VariantFactory3<V1, V1C, V2, V3, V1R, V2R, V3R>
where V1: ServiceFactory<V1R, V1C>, V1C: Clone, V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V3: ServiceFactory<V3R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService3<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, V1R, V2R, V3R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V3, V1R, V2R, V3R> where VariantFactory3<V1, V1C, V2, V3, V1R, V2R, V3R>: 'f, V1C: 'f

source§

impl<V1, V1C, V2, V3, V4, V1R, V2R, V3R, V4R> ServiceFactory<Variant4<V1R, V2R, V3R, V4R>, V1C> for VariantFactory4<V1, V1C, V2, V3, V4, V1R, V2R, V3R, V4R>
where V1: ServiceFactory<V1R, V1C>, V1C: Clone, V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V3: ServiceFactory<V3R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V4: ServiceFactory<V4R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService4<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, <V4 as ServiceFactory<V4R, V1C>>::Service, V1R, V2R, V3R, V4R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V3, V4, V1R, V2R, V3R, V4R> where VariantFactory4<V1, V1C, V2, V3, V4, V1R, V2R, V3R, V4R>: 'f, V1C: 'f

source§

impl<V1, V1C, V2, V3, V4, V5, V1R, V2R, V3R, V4R, V5R> ServiceFactory<Variant5<V1R, V2R, V3R, V4R, V5R>, V1C> for VariantFactory5<V1, V1C, V2, V3, V4, V5, V1R, V2R, V3R, V4R, V5R>
where V1C: Clone, V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V3: ServiceFactory<V3R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V4: ServiceFactory<V4R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V5: ServiceFactory<V5R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V1: ServiceFactory<V1R, V1C>,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService5<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, <V4 as ServiceFactory<V4R, V1C>>::Service, <V5 as ServiceFactory<V5R, V1C>>::Service, V1R, V2R, V3R, V4R, V5R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V3, V4, V5, V1R, V2R, V3R, V4R, V5R> where VariantFactory5<V1, V1C, V2, V3, V4, V5, V1R, V2R, V3R, V4R, V5R>: 'f, V1C: 'f

source§

impl<V1, V1C, V2, V3, V4, V5, V6, V1R, V2R, V3R, V4R, V5R, V6R> ServiceFactory<Variant6<V1R, V2R, V3R, V4R, V5R, V6R>, V1C> for VariantFactory6<V1, V1C, V2, V3, V4, V5, V6, V1R, V2R, V3R, V4R, V5R, V6R>
where V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V3: ServiceFactory<V3R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V4: ServiceFactory<V4R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V5: ServiceFactory<V5R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V6: ServiceFactory<V6R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V1: ServiceFactory<V1R, V1C>, V1C: Clone,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService6<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, <V4 as ServiceFactory<V4R, V1C>>::Service, <V5 as ServiceFactory<V5R, V1C>>::Service, <V6 as ServiceFactory<V6R, V1C>>::Service, V1R, V2R, V3R, V4R, V5R, V6R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V3, V4, V5, V6, V1R, V2R, V3R, V4R, V5R, V6R> where VariantFactory6<V1, V1C, V2, V3, V4, V5, V6, V1R, V2R, V3R, V4R, V5R, V6R>: 'f, V1C: 'f

source§

impl<V1, V1C, V2, V3, V4, V5, V6, V7, V1R, V2R, V3R, V4R, V5R, V6R, V7R> ServiceFactory<Variant7<V1R, V2R, V3R, V4R, V5R, V6R, V7R>, V1C> for VariantFactory7<V1, V1C, V2, V3, V4, V5, V6, V7, V1R, V2R, V3R, V4R, V5R, V6R, V7R>
where V3: ServiceFactory<V3R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V4: ServiceFactory<V4R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V5: ServiceFactory<V5R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V6: ServiceFactory<V6R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V7: ServiceFactory<V7R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V1: ServiceFactory<V1R, V1C>, V1C: Clone, V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService7<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, <V4 as ServiceFactory<V4R, V1C>>::Service, <V5 as ServiceFactory<V5R, V1C>>::Service, <V6 as ServiceFactory<V6R, V1C>>::Service, <V7 as ServiceFactory<V7R, V1C>>::Service, V1R, V2R, V3R, V4R, V5R, V6R, V7R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V3, V4, V5, V6, V7, V1R, V2R, V3R, V4R, V5R, V6R, V7R> where VariantFactory7<V1, V1C, V2, V3, V4, V5, V6, V7, V1R, V2R, V3R, V4R, V5R, V6R, V7R>: 'f, V1C: 'f

source§

impl<V1, V1C, V2, V3, V4, V5, V6, V7, V8, V1R, V2R, V3R, V4R, V5R, V6R, V7R, V8R> ServiceFactory<Variant8<V1R, V2R, V3R, V4R, V5R, V6R, V7R, V8R>, V1C> for VariantFactory8<V1, V1C, V2, V3, V4, V5, V6, V7, V8, V1R, V2R, V3R, V4R, V5R, V6R, V7R, V8R>
where V3: ServiceFactory<V3R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V4: ServiceFactory<V4R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V5: ServiceFactory<V5R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V6: ServiceFactory<V6R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V7: ServiceFactory<V7R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V1: ServiceFactory<V1R, V1C>, V8: ServiceFactory<V8R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>, V1C: Clone, V2: ServiceFactory<V2R, V1C, Response = <V1 as ServiceFactory<V1R, V1C>>::Response, Error = <V1 as ServiceFactory<V1R, V1C>>::Error, InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError>,

§

type Response = <V1 as ServiceFactory<V1R, V1C>>::Response

§

type Error = <V1 as ServiceFactory<V1R, V1C>>::Error

§

type InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

§

type Service = VariantService8<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, <V4 as ServiceFactory<V4R, V1C>>::Service, <V5 as ServiceFactory<V5R, V1C>>::Service, <V6 as ServiceFactory<V6R, V1C>>::Service, <V7 as ServiceFactory<V7R, V1C>>::Service, <V8 as ServiceFactory<V8R, V1C>>::Service, V1R, V2R, V3R, V4R, V5R, V6R, V7R, V8R>

§

type Future<'f> = ServiceFactoryResponse<'f, V1, V1C, V2, V3, V4, V5, V6, V7, V8, V1R, V2R, V3R, V4R, V5R, V6R, V7R, V8R> where VariantFactory8<V1, V1C, V2, V3, V4, V5, V6, V7, V8, V1R, V2R, V3R, V4R, V5R, V6R, V7R, V8R>: 'f, V1C: 'f