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;

    // Required method
    fn create(
        &self,
        cfg: Cfg
    ) -> impl Future<Output = Result<Self::Service, Self::InitError>>;

    // Provided methods
    async fn pipeline(
        &self,
        cfg: Cfg
    ) -> Result<Pipeline<Self::Service>, Self::InitError>
       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.

Required Methods§

source

fn create( &self, cfg: Cfg ) -> impl Future<Output = Result<Self::Service, Self::InitError>>

Create and return a new service value asynchronously.

Provided Methods§

source

async fn pipeline( &self, cfg: Cfg ) -> Result<Pipeline<Self::Service>, Self::InitError>
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>
where Ctl: ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>, Response = ControlAck> + 'static, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>>>::Error: Debug, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>>>::InitError: Debug, Pub: ServiceFactory<Message, Response = ()> + 'static, <Pub as ServiceFactory<Message>>::Error: Debug, <Pub as ServiceFactory<Message>>::InitError: Debug,

§

type Response = ()

§

type Error = ServerError<()>

§

type Service = ServerHandler<Ctl, Pub>

§

type InitError = ()

source§

async fn create( &self, _: () ) -> Result<<Server<Ctl, Pub> as ServiceFactory<IoBoxed>>::Service, <Server<Ctl, Pub> as ServiceFactory<IoBoxed>>::InitError>

source§

impl<F, Ctl, Pub> ServiceFactory<Io<F>> for Server<Ctl, Pub>
where F: Filter, Ctl: ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>, Response = ControlAck> + 'static, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>>>::Error: Debug, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>>>::InitError: Debug, Pub: ServiceFactory<Message, Response = ()> + 'static, <Pub as ServiceFactory<Message>>::Error: Debug, <Pub as ServiceFactory<Message>>::InitError: Debug,

§

type Response = ()

§

type Error = ServerError<()>

§

type Service = ServerHandler<Ctl, Pub>

§

type InitError = ()

source§

async fn create( &self, _: () ) -> Result<<Server<Ctl, Pub> as ServiceFactory<Io<F>>>::Service, <Server<Ctl, Pub> as ServiceFactory<Io<F>>>::InitError>

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

source§

async fn create( &self, cfg: Cfg ) -> Result<<Rc<S> as ServiceFactory<Req, Cfg>>::Service, <Rc<S> as ServiceFactory<Req, Cfg>>::InitError>

Implementors§

source§

impl ServiceFactory<Control<H2Error>> for ntex::http::h2::DefaultControlService

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

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

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

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

source§

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

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

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

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

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>

source§

impl<F, C> ServiceFactory<Io<F>, C> for SslAcceptor
where F: Filter,

source§

impl<F, C> ServiceFactory<Io<F>, C> for TlsAcceptor
where F: Filter,

source§

impl<F, Err> ServiceFactory<Control<F, Err>> for ntex::http::h1::DefaultControlService
where F: Filter, Err: ResponseError,

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

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 = ()

source§

impl<F, S, B, C1, C2> ServiceFactory<Io<F>> for HttpService<F, S, B, C1, C2>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C1: ServiceFactory<Control<F, S::Error>, Response = ControlAck> + 'static, C1::Error: Error, C1::InitError: Debug, C2: ServiceFactory<Control<H2Error>, Response = ControlAck> + 'static, C2::Error: Error, C2::InitError: Debug,

§

type Response = ()

§

type Error = DispatchError

§

type InitError = ()

§

type Service = HttpServiceHandler<F, <S as ServiceFactory<Request>>::Service, B, <C1 as ServiceFactory<Control<F, <S as ServiceFactory<Request>>::Error>>>::Service, C2>

source§

impl<F, S, B, C> ServiceFactory<Io<F>> for H1Service<F, S, B, C>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, Response = ControlAck> + 'static, C::Error: Error, C::InitError: Debug,

source§

impl<F, S, B, C> ServiceFactory<Io<F>> for H2Service<F, S, B, C>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C: ServiceFactory<Control<H2Error>, Response = ControlAck> + 'static, C::Error: Error, C::InitError: Debug,

§

type Response = ()

§

type Error = DispatchError

§

type InitError = ()

§

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

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

source§

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

§

type Response = R

§

type Error = E

§

type Service = KeepAliveService<R, E, F>

§

type InitError = Infallible

source§

impl<T, C> ServiceFactory<Connect<T>, C> for Connector<T>
where T: Address,

source§

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

source§

impl<T, C> ServiceFactory<Connect<T>, C> for SslConnector<T>
where T: Address,

source§

impl<T, C> ServiceFactory<Connect<T>, C> for TlsConnector<T>
where T: Address,

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

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

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

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 Service = VariantService2<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, V1R, V2R>

§

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

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 Service = VariantService3<<V1 as ServiceFactory<V1R, V1C>>::Service, <V2 as ServiceFactory<V2R, V1C>>::Service, <V3 as ServiceFactory<V3R, V1C>>::Service, V1R, V2R, V3R>

§

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

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 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 InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

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 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 InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

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 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 InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

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 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 InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError

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 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 InitError = <V1 as ServiceFactory<V1R, V1C>>::InitError