mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-04 21:37:58 +03:00
Code Issues Projects Releases Packages Wiki Activity

ServiceFactory takes config type as a type parameter instead of an associated type

Browse source
This commit is contained in:
Nikolay Kim 2021-12-24 03:52:57 +06:00
parent 8d65da2f4d
commit 359d94fd5a
13 changed files with 242 additions and 289 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex-service/CHANGES.md
View file

@ -2,7 +2,9 @@
## [0.3.0] - 2021-12-xx ## [0.3.0] - 2021-12-xx
* Service now takes the the request type as a type parameter instead of an associated type * Service takes request type as a type parameter instead of an associated type
* ServiceFactory takes config type as a type parameter instead of an associated type
## [0.2.1] - 2021-09-17 ## [0.2.1] - 2021-09-17

55
ntex-service/src/and_then.rs
View file

@ -126,21 +126,16 @@ where
} }
/// `.and_then()` service factory combinator /// `.and_then()` service factory combinator
pub struct AndThenFactory<A, B, Req> { pub struct AndThenFactory<A, B, Req, Cfg> {
inner: Rc<(A, B)>, inner: Rc<(A, B)>,
_t: PhantomData<fn(Req)>, _t: PhantomData<fn(Req, Cfg)>,
} }
impl<A, B, Req> AndThenFactory<A, B, Req> impl<A, B, Req, Cfg> AndThenFactory<A, B, Req, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
A::Config: Clone, B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
B: ServiceFactory< Cfg: Clone,
A::Response,
Config = A::Config,
Error = A::Error,
InitError = A::InitError,
>,
{ {
/// Create new `AndThenFactory` combinator /// Create new `AndThenFactory` combinator
pub(crate) fn new(a: A, b: B) -> Self { pub(crate) fn new(a: A, b: B) -> Self {
@ -151,26 +146,20 @@ where
} }
} }
impl<A, B, Req> ServiceFactory<Req> for AndThenFactory<A, B, Req> impl<A, B, Req, Cfg> ServiceFactory<Req, Cfg> for AndThenFactory<A, B, Req, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
A::Config: Clone, B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
B: ServiceFactory< Cfg: Clone,
A::Response,
Config = A::Config,
Error = A::Error,
InitError = A::InitError,
>,
{ {
type Response = B::Response; type Response = B::Response;
type Error = A::Error; type Error = A::Error;
type Config = A::Config;
type Service = AndThen<A::Service, B::Service, Req>; type Service = AndThen<A::Service, B::Service, Req>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = AndThenServiceFactoryResponse<A, B, Req>; type Future = AndThenServiceFactoryResponse<A, B, Req, Cfg>;
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: Cfg) -> Self::Future {
let inner = &*self.inner; let inner = &*self.inner;
AndThenServiceFactoryResponse::new( AndThenServiceFactoryResponse::new(
inner.0.new_service(cfg.clone()), inner.0.new_service(cfg.clone()),
@ -179,7 +168,7 @@ where
} }
} }
impl<A, B, Req> Clone for AndThenFactory<A, B, Req> { impl<A, B, Req, Cfg> Clone for AndThenFactory<A, B, Req, Cfg> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
inner: self.inner.clone(), inner: self.inner.clone(),
@ -189,10 +178,10 @@ impl<A, B, Req> Clone for AndThenFactory<A, B, Req> {
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct AndThenServiceFactoryResponse<A, B, Req> pub struct AndThenServiceFactoryResponse<A, B, Req, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response>, B: ServiceFactory<A::Response, Cfg>,
{ {
#[pin] #[pin]
fut_a: A::Future, fut_a: A::Future,
@ -204,10 +193,10 @@ pin_project_lite::pin_project! {
} }
} }
impl<A, B, Req> AndThenServiceFactoryResponse<A, B, Req> impl<A, B, Req, Cfg> AndThenServiceFactoryResponse<A, B, Req, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response>, B: ServiceFactory<A::Response, Cfg>,
{ {
fn new(fut_a: A::Future, fut_b: B::Future) -> Self { fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
AndThenServiceFactoryResponse { AndThenServiceFactoryResponse {
@ -219,10 +208,10 @@ where
} }
} }
impl<A, B, Req> Future for AndThenServiceFactoryResponse<A, B, Req> impl<A, B, Req, Cfg> Future for AndThenServiceFactoryResponse<A, B, Req, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Error = A::Error, InitError = A::InitError>, B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
{ {
type Output = Result<AndThen<A::Service, B::Service, Req>, A::InitError>; type Output = Result<AndThen<A::Service, B::Service, Req>, A::InitError>;

50
ntex-service/src/apply.rs
View file

@ -17,15 +17,15 @@ where
} }
/// Service factory that prodices `apply_fn` service. /// Service factory that prodices `apply_fn` service.
pub fn apply_fn_factory<T, Req, F, R, In, Out, Err, U>( pub fn apply_fn_factory<T, Req, Cfg, F, R, In, Out, Err, U>(
service: U, service: U,
f: F, f: F,
) -> ApplyServiceFactory<T, Req, F, R, In, Out, Err> ) -> ApplyServiceFactory<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
U: IntoServiceFactory<T, Req>, U: IntoServiceFactory<T, Req, Cfg>,
{ {
ApplyServiceFactory::new(service.into_factory(), f) ApplyServiceFactory::new(service.into_factory(), f)
} }
@ -98,20 +98,20 @@ where
} }
/// `apply()` service factory /// `apply()` service factory
pub struct ApplyServiceFactory<T, Req, F, R, In, Out, Err> pub struct ApplyServiceFactory<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
service: T, service: T,
f: F, f: F,
r: PhantomData<fn(Req) -> (R, In, Out)>, r: PhantomData<fn(Req, Cfg) -> (R, In, Out)>,
} }
impl<T, Req, F, R, In, Out, Err> ApplyServiceFactory<T, Req, F, R, In, Out, Err> impl<T, Req, Cfg, F, R, In, Out, Err> ApplyServiceFactory<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
@ -125,10 +125,10 @@ where
} }
} }
impl<T, Req, F, R, In, Out, Err> Clone impl<T, Req, Cfg, F, R, In, Out, Err> Clone
for ApplyServiceFactory<T, Req, F, R, In, Out, Err> for ApplyServiceFactory<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err> + Clone, T: ServiceFactory<Req, Cfg, Error = Err> + Clone,
F: Fn(In, &T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
@ -141,30 +141,29 @@ where
} }
} }
impl<T, Req, F, R, In, Out, Err> ServiceFactory<In> impl<T, Req, Cfg, F, R, In, Out, Err> ServiceFactory<In, Cfg>
for ApplyServiceFactory<T, Req, F, R, In, Out, Err> for ApplyServiceFactory<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
type Response = Out; type Response = Out;
type Error = Err; type Error = Err;
type Config = T::Config;
type Service = Apply<T::Service, Req, F, R, In, Out, Err>; type Service = Apply<T::Service, Req, F, R, In, Out, Err>;
type InitError = T::InitError; type InitError = T::InitError;
type Future = ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err>; type Future = ApplyServiceFactoryResponse<T, Req, Cfg, F, R, In, Out, Err>;
fn new_service(&self, cfg: T::Config) -> Self::Future { fn new_service(&self, cfg: Cfg) -> Self::Future {
ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone()) ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
} }
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err> pub struct ApplyServiceFactoryResponse<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R, F: Fn(In, &T::Service) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
@ -175,9 +174,10 @@ pin_project_lite::pin_project! {
} }
} }
impl<T, Req, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err> impl<T, Req, Cfg, F, R, In, Out, Err>
ApplyServiceFactoryResponse<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R, F: Fn(In, &T::Service) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
@ -190,10 +190,10 @@ where
} }
} }
impl<T, Req, F, R, In, Out, Err> Future impl<T, Req, Cfg, F, R, In, Out, Err> Future
for ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err> for ApplyServiceFactoryResponse<T, Req, Cfg, F, R, In, Out, Err>
where where
T: ServiceFactory<Req, Error = Err>, T: ServiceFactory<Req, Cfg, Error = Err>,
F: Fn(In, &T::Service) -> R, F: Fn(In, &T::Service) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {

27
ntex-service/src/boxed.rs
View file

@ -12,17 +12,16 @@ pub type BoxService<Req, Res, Err> =
pub type RcService<Req, Res, Err> = pub type RcService<Req, Res, Err> =
Rc<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>; Rc<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>( pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
Inner<C, Req, Res, Err, InitErr>,
);
/// Create boxed service factory /// Create boxed service factory
pub fn factory<T, R>( pub fn factory<T, R, C>(
factory: T, factory: T,
) -> BoxServiceFactory<T::Config, R, T::Response, T::Error, T::InitError> ) -> BoxServiceFactory<C, R, T::Response, T::Error, T::InitError>
where where
C: 'static,
R: 'static, R: 'static,
T: ServiceFactory<R> + 'static, T: ServiceFactory<R, C> + 'static,
T::Response: 'static, T::Response: 'static,
T::Error: 'static, T::Error: 'static,
T::InitError: 'static, T::InitError: 'static,
@ -56,7 +55,7 @@ where
type Inner<C, Req, Res, Err, InitErr> = Box< type Inner<C, Req, Res, Err, InitErr> = Box<
dyn ServiceFactory< dyn ServiceFactory<
Req, Req,
Config = C, C,
Response = Res, Response = Res,
Error = Err, Error = Err,
InitError = InitErr, InitError = InitErr,
@ -65,7 +64,7 @@ type Inner<C, Req, Res, Err, InitErr> = Box<
>, >,
>; >;
impl<C, Req, Res, Err, InitErr> ServiceFactory<Req> impl<C, Req, Res, Err, InitErr> ServiceFactory<Req, C>
for BoxServiceFactory<C, Req, Res, Err, InitErr> for BoxServiceFactory<C, Req, Res, Err, InitErr>
where where
Req: 'static, Req: 'static,
@ -76,7 +75,6 @@ where
type Response = Res; type Response = Res;
type Error = Err; type Error = Err;
type InitError = InitErr; type InitError = InitErr;
type Config = C;
type Service = BoxService<Req, Res, Err>; type Service = BoxService<Req, Res, Err>;
type Future = BoxFuture<Self::Service, InitErr>; type Future = BoxFuture<Self::Service, InitErr>;
@ -86,24 +84,25 @@ where
} }
} }
struct FactoryWrapper<C, R, T: ServiceFactory<R>> { struct FactoryWrapper<C, R, T: ServiceFactory<R, C>> {
factory: T, factory: T,
_t: std::marker::PhantomData<(C, R)>, _t: std::marker::PhantomData<(C, R)>,
} }
impl<C, R, T, Res, Err, InitErr> ServiceFactory<R> for FactoryWrapper<C, R, T> impl<C, R, T, Res, Err, InitErr> ServiceFactory<R, C> for FactoryWrapper<C, R, T>
where where
R: 'static, R: 'static,
Res: 'static, Res: 'static,
Err: 'static, Err: 'static,
InitErr: 'static, InitErr: 'static,
T: ServiceFactory<R, Config = C, Response = Res, Error = Err, InitError = InitErr> T: ServiceFactory<R, C, Response = Res, Error = Err, InitError = InitErr> + 'static,
+ 'static, T::Service: 'static,
T::Future: 'static,
<T::Service as Service<R>>::Future: 'static,
{ {
type Response = Res; type Response = Res;
type Error = Err; type Error = Err;
type InitError = InitErr; type InitError = InitErr;
type Config = C;
type Service = BoxService<R, Res, Err>; type Service = BoxService<R, Res, Err>;
type Future = BoxFuture<Self::Service, Self::InitError>; type Future = BoxFuture<Self::Service, Self::InitError>;

16
ntex-service/src/fn_service.rs
View file

@ -163,8 +163,7 @@ where
} }
} }
impl<F, Fut, Req, Res, Err, FShut> Service<Req> impl<F, Fut, Req, Res, Err, FShut> Service<Req> for FnService<F, Fut, Req, Res, Err, FShut>
for FnService<F, Fut, Req, Res, Err, FShut>
where where
F: Fn(Req) -> Fut, F: Fn(Req) -> Fut,
FShut: FnOnce(), FShut: FnOnce(),
@ -293,7 +292,7 @@ where
} }
} }
impl<F, Fut, Req, Res, Err, Cfg, FShut> ServiceFactory<Req> impl<F, Fut, Req, Res, Err, Cfg, FShut> ServiceFactory<Req, Cfg>
for FnServiceFactory<F, Fut, Req, Res, Err, Cfg, FShut> for FnServiceFactory<F, Fut, Req, Res, Err, Cfg, FShut>
where where
F: Fn(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
@ -303,7 +302,6 @@ where
type Response = Res; type Response = Res;
type Error = Err; type Error = Err;
type Config = Cfg;
type Service = FnService<F, Fut, Req, Res, Err, FShut>; type Service = FnService<F, Fut, Req, Res, Err, FShut>;
type InitError = (); type InitError = ();
type Future = Ready<Self::Service, Self::InitError>; type Future = Ready<Self::Service, Self::InitError>;
@ -322,7 +320,7 @@ where
} }
impl<F, Fut, Req, Res, Err, Cfg> impl<F, Fut, Req, Res, Err, Cfg>
IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>, Req> for F IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>, Req, Cfg> for F
where where
F: Fn(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
@ -370,7 +368,7 @@ where
} }
} }
impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req> impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req, Cfg>
for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err> for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
where where
F: Fn(Cfg) -> Fut, F: Fn(Cfg) -> Fut,
@ -380,7 +378,6 @@ where
type Response = Srv::Response; type Response = Srv::Response;
type Error = Srv::Error; type Error = Srv::Error;
type Config = Cfg;
type Service = Srv; type Service = Srv;
type InitError = Err; type InitError = Err;
type Future = Fut; type Future = Fut;
@ -413,7 +410,7 @@ where
} }
} }
impl<F, C, S, R, Req, E> ServiceFactory<Req> for FnServiceNoConfig<F, C, S, R, Req, E> impl<F, C, S, R, Req, E> ServiceFactory<Req, C> for FnServiceNoConfig<F, C, S, R, Req, E>
where where
F: Fn() -> R, F: Fn() -> R,
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
@ -422,7 +419,6 @@ where
type Response = S::Response; type Response = S::Response;
type Error = S::Error; type Error = S::Error;
type Service = S; type Service = S;
type Config = C;
type InitError = E; type InitError = E;
type Future = R; type Future = R;
@ -444,7 +440,7 @@ where
} }
} }
impl<F, C, S, R, Req, E> IntoServiceFactory<FnServiceNoConfig<F, C, S, R, Req, E>, Req> impl<F, C, S, R, Req, E> IntoServiceFactory<FnServiceNoConfig<F, C, S, R, Req, E>, Req, C>
for F for F
where where
F: Fn() -> R, F: Fn() -> R,

36
ntex-service/src/lib.rs
View file

@ -156,16 +156,13 @@ pub trait Service<Req> {
/// requests on that new TCP stream. /// requests on that new TCP stream.
/// ///
/// `Config` is a service factory configuration type. /// `Config` is a service factory configuration type.
pub trait ServiceFactory<Req> { pub trait ServiceFactory<Req, Cfg = ()> {
/// Responses given by the service /// Responses given by the service
type Response; type Response;
/// Errors produced by the service /// Errors produced by the service
type Error; type Error;
/// Service factory configuration
type Config;
/// The `Service` value created by this factory /// The `Service` value created by this factory
type Service: Service<Req, Response = Self::Response, Error = Self::Error>; type Service: Service<Req, Response = Self::Response, Error = Self::Error>;
@ -176,12 +173,12 @@ pub trait ServiceFactory<Req> {
type Future: Future<Output = Result<Self::Service, Self::InitError>>; type Future: Future<Output = Result<Self::Service, Self::InitError>>;
/// Create and return a new service value asynchronously. /// Create and return a new service value asynchronously.
fn new_service(&self, cfg: Self::Config) -> Self::Future; fn new_service(&self, cfg: Cfg) -> Self::Future;
#[inline] #[inline]
/// Map this service's output to a different type, returning a new service /// Map this service's output to a different type, returning a new service
/// of the resulting type. /// of the resulting type.
fn map<F, Res>(self, f: F) -> crate::map::MapServiceFactory<Self, F, Req, Res> fn map<F, Res>(self, f: F) -> crate::map::MapServiceFactory<Self, F, Req, Res, Cfg>
where where
Self: Sized, Self: Sized,
F: FnMut(Self::Response) -> Res + Clone, F: FnMut(Self::Response) -> Res + Clone,
@ -191,17 +188,23 @@ pub trait ServiceFactory<Req> {
#[inline] #[inline]
/// Map this service's error to a different error, returning a new service. /// Map this service's error to a different error, returning a new service.
fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, Req, F, E> fn map_err<F, E>(
self,
f: F,
) -> crate::map_err::MapErrServiceFactory<Self, Req, Cfg, F, E>
where where
Self: Sized, Self: Sized,
F: Fn(Self::Error) -> E + Clone, F: Fn(Self::Error) -> E + Clone,
{ {
crate::map_err::MapErrServiceFactory::new(self, f) crate::map_err::MapErrServiceFactory::<_, _, Cfg, _, _>::new(self, f)
} }
#[inline] #[inline]
/// Map this factory's init error to a different error, returning a new service. /// Map this factory's init error to a different error, returning a new service.
fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, Req, F, E> fn map_init_err<F, E>(
self,
f: F,
) -> crate::map_init_err::MapInitErr<Self, Req, Cfg, F, E>
where where
Self: Sized, Self: Sized,
F: Fn(Self::InitError) -> E + Clone, F: Fn(Self::InitError) -> E + Clone,
@ -256,18 +259,17 @@ where
} }
} }
impl<S, Req> ServiceFactory<Req> for Rc<S> impl<S, Req, Cfg> ServiceFactory<Req, Cfg> for Rc<S>
where where
S: ServiceFactory<Req>, S: ServiceFactory<Req, Cfg>,
{ {
type Response = S::Response; type Response = S::Response;
type Error = S::Error; type Error = S::Error;
type Config = S::Config;
type Service = S::Service; type Service = S::Service;
type InitError = S::InitError; type InitError = S::InitError;
type Future = S::Future; type Future = S::Future;
fn new_service(&self, cfg: S::Config) -> S::Future { fn new_service(&self, cfg: Cfg) -> S::Future {
self.as_ref().new_service(cfg) self.as_ref().new_service(cfg)
} }
} }
@ -282,9 +284,9 @@ where
} }
/// Trait for types that can be converted to a `ServiceFactory` /// Trait for types that can be converted to a `ServiceFactory`
pub trait IntoServiceFactory<T, Req> pub trait IntoServiceFactory<T, Req, Cfg = ()>
where where
T: ServiceFactory<Req>, T: ServiceFactory<Req, Cfg>,
{ {
/// Convert `Self` to a `ServiceFactory` /// Convert `Self` to a `ServiceFactory`
fn into_factory(self) -> T; fn into_factory(self) -> T;
@ -299,9 +301,9 @@ where
} }
} }
impl<T, Req> IntoServiceFactory<T, Req> for T impl<T, Req, Cfg> IntoServiceFactory<T, Req, Cfg> for T
where where
T: ServiceFactory<Req>, T: ServiceFactory<Req, Cfg>,
{ {
fn into_factory(self) -> T { fn into_factory(self) -> T {
self self

32
ntex-service/src/map.rs
View file

@ -107,17 +107,17 @@ where
} }
/// `MapNewService` new service combinator /// `MapNewService` new service combinator
pub struct MapServiceFactory<A, F, Req, Res> { pub struct MapServiceFactory<A, F, Req, Res, Cfg> {
a: A, a: A,
f: F, f: F,
r: PhantomData<fn(Req) -> Res>, r: PhantomData<fn(Req, Cfg) -> Res>,
} }
impl<A, F, Req, Res> MapServiceFactory<A, F, Req, Res> { impl<A, F, Req, Res, Cfg> MapServiceFactory<A, F, Req, Res, Cfg> {
/// Create new `Map` new service instance /// Create new `Map` new service instance
pub(crate) fn new(a: A, f: F) -> Self pub(crate) fn new(a: A, f: F) -> Self
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
F: FnMut(A::Response) -> Res, F: FnMut(A::Response) -> Res,
{ {
Self { Self {
@ -128,7 +128,7 @@ impl<A, F, Req, Res> MapServiceFactory<A, F, Req, Res> {
} }
} }
impl<A, F, Req, Res> Clone for MapServiceFactory<A, F, Req, Res> impl<A, F, Req, Res, Cfg> Clone for MapServiceFactory<A, F, Req, Res, Cfg>
where where
A: Clone, A: Clone,
F: Clone, F: Clone,
@ -143,29 +143,29 @@ where
} }
} }
impl<A, F, Req, Res> ServiceFactory<Req> for MapServiceFactory<A, F, Req, Res> impl<A, F, Req, Res, Cfg> ServiceFactory<Req, Cfg>
for MapServiceFactory<A, F, Req, Res, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
F: FnMut(A::Response) -> Res + Clone, F: FnMut(A::Response) -> Res + Clone,
{ {
type Response = Res; type Response = Res;
type Error = A::Error; type Error = A::Error;
type Config = A::Config;
type Service = Map<A::Service, F, Req, Res>; type Service = Map<A::Service, F, Req, Res>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapServiceFuture<A, F, Req, Res>; type Future = MapServiceFuture<A, F, Req, Res, Cfg>;
#[inline] #[inline]
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: Cfg) -> Self::Future {
MapServiceFuture::new(self.a.new_service(cfg), self.f.clone()) MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
} }
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct MapServiceFuture<A, F, Req, Res> pub struct MapServiceFuture<A, F, Req, Res, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
F: FnMut(A::Response) -> Res, F: FnMut(A::Response) -> Res,
{ {
#[pin] #[pin]
@ -174,9 +174,9 @@ pin_project_lite::pin_project! {
} }
} }
impl<A, F, Req, Res> MapServiceFuture<A, F, Req, Res> impl<A, F, Req, Res, Cfg> MapServiceFuture<A, F, Req, Res, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
F: FnMut(A::Response) -> Res, F: FnMut(A::Response) -> Res,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
@ -184,9 +184,9 @@ where
} }
} }
impl<A, F, Req, Res> Future for MapServiceFuture<A, F, Req, Res> impl<A, F, Req, Res, Cfg> Future for MapServiceFuture<A, F, Req, Res, Cfg>
where where
A: ServiceFactory<Req>, A: ServiceFactory<Req, Cfg>,
F: FnMut(A::Response) -> Res, F: FnMut(A::Response) -> Res,
{ {
type Output = Result<Map<A::Service, F, Req, Res>, A::InitError>; type Output = Result<Map<A::Service, F, Req, Res>, A::InitError>;

113
ntex-service/src/map_config.rs
View file

@ -7,11 +7,11 @@ use super::{IntoServiceFactory, Service, ServiceFactory};
/// ///
/// Note that this function consumes the receiving service factory and returns /// Note that this function consumes the receiving service factory and returns
/// a wrapped version of it. /// a wrapped version of it.
pub fn map_config<T, R, U, F, C>(factory: U, f: F) -> MapConfig<T, R, F, C> pub fn map_config<T, R, U, F, C, C2>(factory: U, f: F) -> MapConfig<T, R, F, C, C2>
where where
T: ServiceFactory<R>, T: ServiceFactory<R, C2>,
U: IntoServiceFactory<T, R>, U: IntoServiceFactory<T, R, C2>,
F: Fn(C) -> T::Config, F: Fn(C) -> C2,
{ {
MapConfig::new(factory.into_factory(), f) MapConfig::new(factory.into_factory(), f)
} }
@ -19,21 +19,15 @@ where
/// Adapt external config argument to a config for provided service factory /// Adapt external config argument to a config for provided service factory
/// ///
/// This function uses service for converting config. /// This function uses service for converting config.
pub fn map_config_service<T, R, M, C, U1, U2>( pub fn map_config_service<T, R, M, C, C2, U1, U2>(
factory: U1, factory: U1,
mapper: U2, mapper: U2,
) -> MapConfigService<T, R, M, C> ) -> MapConfigService<T, R, M, C, C2>
where where
T: ServiceFactory<R>, T: ServiceFactory<R, C2>,
M: ServiceFactory< M: ServiceFactory<C, (), Response = C2, Error = T::InitError, InitError = T::InitError>,
C, U1: IntoServiceFactory<T, R, C2>,
Config = (), U2: IntoServiceFactory<M, C, ()>,
Response = T::Config,
Error = T::InitError,
InitError = T::InitError,
>,
U1: IntoServiceFactory<T, R>,
U2: IntoServiceFactory<M, C>,
{ {
MapConfigService::new(factory.into_factory(), mapper.into_factory()) MapConfigService::new(factory.into_factory(), mapper.into_factory())
} }
@ -41,25 +35,25 @@ where
/// Replace config with unit /// Replace config with unit
pub fn unit_config<T, R, U, C>(factory: U) -> UnitConfig<T, R, C> pub fn unit_config<T, R, U, C>(factory: U) -> UnitConfig<T, R, C>
where where
T: ServiceFactory<R, Config = ()>, T: ServiceFactory<R, ()>,
U: IntoServiceFactory<T, R>, U: IntoServiceFactory<T, R, ()>,
{ {
UnitConfig::new(factory.into_factory()) UnitConfig::new(factory.into_factory())
} }
/// `map_config()` adapter service factory /// `map_config()` adapter service factory
pub struct MapConfig<A, R, F, C> { pub struct MapConfig<A, R, F, C, C2> {
a: A, a: A,
f: F, f: F,
e: PhantomData<(R, C)>, e: PhantomData<(R, C, C2)>,
} }
impl<A, R, F, C> MapConfig<A, R, F, C> { impl<A, R, F, C, C2> MapConfig<A, R, F, C, C2> {
/// Create new `MapConfig` combinator /// Create new `MapConfig` combinator
pub(crate) fn new(a: A, f: F) -> Self pub(crate) fn new(a: A, f: F) -> Self
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C2>,
F: Fn(C) -> A::Config, F: Fn(C) -> C2,
{ {
Self { Self {
a, a,
@ -69,7 +63,7 @@ impl<A, R, F, C> MapConfig<A, R, F, C> {
} }
} }
impl<A, R, F, C> Clone for MapConfig<A, R, F, C> impl<A, R, F, C, C2> Clone for MapConfig<A, R, F, C, C2>
where where
A: Clone, A: Clone,
F: Clone, F: Clone,
@ -83,15 +77,14 @@ where
} }
} }
impl<A, R, F, C> ServiceFactory<R> for MapConfig<A, R, F, C> impl<A, R, F, C, C2> ServiceFactory<R, C> for MapConfig<A, R, F, C, C2>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C2>,
F: Fn(C) -> A::Config, F: Fn(C) -> C2,
{ {
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type Config = C;
type Service = A::Service; type Service = A::Service;
type InitError = A::InitError; type InitError = A::InitError;
type Future = A::Future; type Future = A::Future;
@ -109,7 +102,7 @@ pub struct UnitConfig<A, R, C> {
impl<A, R, C> UnitConfig<A, R, C> impl<A, R, C> UnitConfig<A, R, C>
where where
A: ServiceFactory<R, Config = ()>, A: ServiceFactory<R, ()>,
{ {
/// Create new `UnitConfig` combinator /// Create new `UnitConfig` combinator
pub(crate) fn new(a: A) -> Self { pub(crate) fn new(a: A) -> Self {
@ -129,14 +122,13 @@ where
} }
} }
impl<A, R, C> ServiceFactory<R> for UnitConfig<A, R, C> impl<A, R, C> ServiceFactory<R, C> for UnitConfig<A, R, C>
where where
A: ServiceFactory<R, Config = ()>, A: ServiceFactory<R, ()>,
{ {
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type Config = C;
type Service = A::Service; type Service = A::Service;
type InitError = A::InitError; type InitError = A::InitError;
type Future = A::Future; type Future = A::Future;
@ -147,30 +139,32 @@ where
} }
/// `map_config_service()` adapter service factory /// `map_config_service()` adapter service factory
pub struct MapConfigService<A, R, M: ServiceFactory<C>, C>(Rc<Inner<A, R, M, C>>); pub struct MapConfigService<A, R, M: ServiceFactory<C, ()>, C, C2>(
Rc<Inner<A, R, M, C, C2>>,
);
struct Inner<A, R, M: ServiceFactory<C>, C> { struct Inner<A, R, M: ServiceFactory<C, ()>, C, C2> {
a: A, a: A,
m: M, m: M,
mapper: RefCell<Option<M::Service>>, mapper: RefCell<Option<M::Service>>,
e: PhantomData<(R, C)>, e: PhantomData<(R, C, C2)>,
} }
impl<A, R, M: ServiceFactory<C>, C> Clone for MapConfigService<A, R, M, C> { impl<A, R, M: ServiceFactory<C, ()>, C, C2> Clone for MapConfigService<A, R, M, C, C2> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self(self.0.clone()) Self(self.0.clone())
} }
} }
impl<A, R, M: ServiceFactory<C>, C> MapConfigService<A, R, M, C> { impl<A, R, M: ServiceFactory<C, ()>, C, C2> MapConfigService<A, R, M, C, C2> {
/// Create new `MapConfigService` combinator /// Create new `MapConfigService` combinator
pub(crate) fn new(a: A, m: M) -> Self pub(crate) fn new(a: A, m: M) -> Self
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C2>,
M: ServiceFactory< M: ServiceFactory<
C, C,
Config = (), (),
Response = A::Config, Response = C2,
Error = A::InitError, Error = A::InitError,
InitError = A::InitError, InitError = A::InitError,
>, >,
@ -184,24 +178,17 @@ impl<A, R, M: ServiceFactory<C>, C> MapConfigService<A, R, M, C> {
} }
} }
impl<A, R, M, C> ServiceFactory<R> for MapConfigService<A, R, M, C> impl<A, R, M, C, C2> ServiceFactory<R, C> for MapConfigService<A, R, M, C, C2>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C2>,
M: ServiceFactory< M: ServiceFactory<C, (), Response = C2, Error = A::InitError, InitError = A::InitError>,
C,
Config = (),
Response = A::Config,
Error = A::InitError,
InitError = A::InitError,
>,
{ {
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type Config = C;
type Service = A::Service; type Service = A::Service;
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapConfigServiceResponse<A, R, M, C>; type Future = MapConfigServiceResponse<A, R, M, C, C2>;
fn new_service(&self, cfg: C) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
let inner = self.0.clone(); let inner = self.0.clone();
@ -224,21 +211,21 @@ where
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct MapConfigServiceResponse<A, R, M, C> pub struct MapConfigServiceResponse<A, R, M, C, C2>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C2>,
M: ServiceFactory<C>, M: ServiceFactory<C, ()>,
{ {
inner: Rc<Inner<A, R, M, C>>, inner: Rc<Inner<A, R, M, C, C2>>,
config: Option<C>, config: Option<C>,
#[pin] #[pin]
state: ResponseState<A, R, M, C>, state: ResponseState<A, R, M, C, C2>,
} }
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
#[project = ResponseStateProject] #[project = ResponseStateProject]
enum ResponseState<A: ServiceFactory<R>, R, M: ServiceFactory<C>, C> { enum ResponseState<A: ServiceFactory<R, C2>, R, M: ServiceFactory<C, ()>, C, C2> {
CreateMapper { #[pin] fut: M::Future }, CreateMapper { #[pin] fut: M::Future },
MapReady, MapReady,
MapConfig { #[pin] fut: <M::Service as Service<C>>::Future }, MapConfig { #[pin] fut: <M::Service as Service<C>>::Future },
@ -246,16 +233,10 @@ pin_project_lite::pin_project! {
} }
} }
impl<A, R, M, C> Future for MapConfigServiceResponse<A, R, M, C> impl<A, R, M, C, C2> Future for MapConfigServiceResponse<A, R, M, C, C2>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C2>,
M: ServiceFactory< M: ServiceFactory<C, (), Response = C2, Error = A::InitError, InitError = A::InitError>,
C,
Config = (),
Response = A::Config,
Error = A::InitError,
InitError = A::InitError,
>,
{ {
type Output = Result<A::Service, A::InitError>; type Output = Result<A::Service, A::InitError>;

35
ntex-service/src/map_err.rs
View file

@ -106,19 +106,19 @@ where
/// service's error. /// service's error.
/// ///
/// This is created by the `NewServiceExt::map_err` method. /// This is created by the `NewServiceExt::map_err` method.
pub struct MapErrServiceFactory<A, R, F, E> pub struct MapErrServiceFactory<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
a: A, a: A,
f: F, f: F,
e: PhantomData<fn(R) -> E>, e: PhantomData<fn(R, C) -> E>,
} }
impl<A, R, F, E> MapErrServiceFactory<A, R, F, E> impl<A, R, C, F, E> MapErrServiceFactory<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
/// Create new `MapErr` new service instance /// Create new `MapErr` new service instance
@ -131,9 +131,9 @@ where
} }
} }
impl<A, R, F, E> Clone for MapErrServiceFactory<A, R, F, E> impl<A, R, C, F, E> Clone for MapErrServiceFactory<A, R, C, F, E>
where where
A: ServiceFactory<R> + Clone, A: ServiceFactory<R, C> + Clone,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
@ -145,29 +145,28 @@ where
} }
} }
impl<A, R, F, E> ServiceFactory<R> for MapErrServiceFactory<A, R, F, E> impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
type Response = A::Response; type Response = A::Response;
type Error = E; type Error = E;
type Config = A::Config;
type Service = MapErr<A::Service, R, F, E>; type Service = MapErr<A::Service, R, F, E>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapErrServiceFuture<A, R, F, E>; type Future = MapErrServiceFuture<A, R, C, F, E>;
#[inline] #[inline]
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone()) MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
} }
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct MapErrServiceFuture<A, R, F, E> pub struct MapErrServiceFuture<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
#[pin] #[pin]
@ -176,9 +175,9 @@ pin_project_lite::pin_project! {
} }
} }
impl<A, R, F, E> MapErrServiceFuture<A, R, F, E> impl<A, R, C, F, E> MapErrServiceFuture<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
@ -186,9 +185,9 @@ where
} }
} }
impl<A, R, F, E> Future for MapErrServiceFuture<A, R, F, E> impl<A, R, C, F, E> Future for MapErrServiceFuture<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
type Output = Result<MapErr<A::Service, R, F, E>, A::InitError>; type Output = Result<MapErr<A::Service, R, F, E>, A::InitError>;

27
ntex-service/src/map_init_err.rs
View file

@ -3,15 +3,15 @@ use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Po
use super::ServiceFactory; use super::ServiceFactory;
/// `MapInitErr` service combinator /// `MapInitErr` service combinator
pub struct MapInitErr<A, R, F, E> { pub struct MapInitErr<A, R, C, F, E> {
a: A, a: A,
f: F, f: F,
e: PhantomData<fn(R) -> E>, e: PhantomData<fn(R, C) -> E>,
} }
impl<A, R, F, E> MapInitErr<A, R, F, E> impl<A, R, C, F, E> MapInitErr<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E, F: Fn(A::InitError) -> E,
{ {
/// Create new `MapInitErr` combinator /// Create new `MapInitErr` combinator
@ -24,7 +24,7 @@ where
} }
} }
impl<A, R, F, E> Clone for MapInitErr<A, R, F, E> impl<A, R, C, F, E> Clone for MapInitErr<A, R, C, F, E>
where where
A: Clone, A: Clone,
F: Clone, F: Clone,
@ -38,20 +38,19 @@ where
} }
} }
impl<A, R, F, E> ServiceFactory<R> for MapInitErr<A, R, F, E> impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E + Clone, F: Fn(A::InitError) -> E + Clone,
{ {
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type Config = A::Config;
type Service = A::Service; type Service = A::Service;
type InitError = E; type InitError = E;
type Future = MapInitErrFuture<A, R, F, E>; type Future = MapInitErrFuture<A, R, C, F, E>;
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
MapInitErrFuture { MapInitErrFuture {
fut: self.a.new_service(cfg), fut: self.a.new_service(cfg),
f: self.f.clone(), f: self.f.clone(),
@ -60,9 +59,9 @@ where
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct MapInitErrFuture<A, R, F, E> pub struct MapInitErrFuture<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E, F: Fn(A::InitError) -> E,
{ {
f: F, f: F,
@ -71,9 +70,9 @@ pin_project_lite::pin_project! {
} }
} }
impl<A, R, F, E> Future for MapInitErrFuture<A, R, F, E> impl<A, R, C, F, E> Future for MapInitErrFuture<A, R, C, F, E>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E, F: Fn(A::InitError) -> E,
{ {
type Output = Result<A::Service, E>; type Output = Result<A::Service, E>;

54
ntex-service/src/pipeline.rs
View file

@ -22,10 +22,10 @@ where
} }
/// Contruct new pipeline factory with one service factory. /// Contruct new pipeline factory with one service factory.
pub fn pipeline_factory<T, R, F>(factory: F) -> PipelineFactory<T, R> pub fn pipeline_factory<T, R, C, F>(factory: F) -> PipelineFactory<T, R, C>
where where
T: ServiceFactory<R>, T: ServiceFactory<R, C>,
F: IntoServiceFactory<T, R>, F: IntoServiceFactory<T, R, C>,
{ {
PipelineFactory { PipelineFactory {
factory: factory.into_factory(), factory: factory.into_factory(),
@ -174,27 +174,22 @@ impl<T: Service<R>, R> Service<R> for Pipeline<T, R> {
} }
/// Pipeline factory /// Pipeline factory
pub struct PipelineFactory<T, R> { pub struct PipelineFactory<T, R, C = ()> {
factory: T, factory: T,
_t: PhantomData<R>, _t: PhantomData<(R, C)>,
} }
impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> { impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
/// Call another service after call to this one has resolved successfully. /// Call another service after call to this one has resolved successfully.
pub fn and_then<F, U>( pub fn and_then<F, U>(
self, self,
factory: F, factory: F,
) -> PipelineFactory<AndThenFactory<T, U, R>, R> ) -> PipelineFactory<AndThenFactory<T, U, R, C>, R, C>
where where
Self: Sized, Self: Sized,
T::Config: Clone, C: Clone,
F: IntoServiceFactory<U, T::Response>, F: IntoServiceFactory<U, T::Response, C>,
U: ServiceFactory< U: ServiceFactory<T::Response, C, Error = T::Error, InitError = T::InitError>,
T::Response,
Config = T::Config,
Error = T::Error,
InitError = T::InitError,
>,
{ {
PipelineFactory { PipelineFactory {
factory: AndThenFactory::new(self.factory, factory.into_factory()), factory: AndThenFactory::new(self.factory, factory.into_factory()),
@ -238,7 +233,7 @@ impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> {
/// Apply transform to current service factory. /// Apply transform to current service factory.
/// ///
/// Short version of `apply(transform, pipeline_factory(...))` /// Short version of `apply(transform, pipeline_factory(...))`
pub fn apply<U>(self, tr: U) -> PipelineFactory<ApplyTransform<U, T, R>, R> pub fn apply<U>(self, tr: U) -> PipelineFactory<ApplyTransform<U, T, R, C>, R, C>
where where
U: Transform<T::Service>, U: Transform<T::Service>,
{ {
@ -254,14 +249,14 @@ impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> {
/// ///
/// Note that this function consumes the receiving pipeline and returns a /// Note that this function consumes the receiving pipeline and returns a
/// wrapped version of it. /// wrapped version of it.
pub fn then<F, U>(self, factory: F) -> PipelineFactory<ThenFactory<T, U, R>, R> pub fn then<F, U>(self, factory: F) -> PipelineFactory<ThenFactory<T, U, R>, R, C>
where where
Self: Sized, Self: Sized,
T::Config: Clone, C: Clone,
F: IntoServiceFactory<U, Result<T::Response, T::Error>>, F: IntoServiceFactory<U, Result<T::Response, T::Error>, C>,
U: ServiceFactory< U: ServiceFactory<
Result<T::Response, T::Error>, Result<T::Response, T::Error>,
Config = T::Config, C,
Error = T::Error, Error = T::Error,
InitError = T::InitError, InitError = T::InitError,
>, >,
@ -274,7 +269,10 @@ impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> {
/// Map this service's output to a different type, returning a new service /// Map this service's output to a different type, returning a new service
/// of the resulting type. /// of the resulting type.
pub fn map<F, Res>(self, f: F) -> PipelineFactory<MapServiceFactory<T, F, R, Res>, R> pub fn map<F, Res>(
self,
f: F,
) -> PipelineFactory<MapServiceFactory<T, F, R, Res, C>, R, C>
where where
Self: Sized, Self: Sized,
F: FnMut(T::Response) -> Res + Clone, F: FnMut(T::Response) -> Res + Clone,
@ -289,7 +287,7 @@ impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> {
pub fn map_err<F, E>( pub fn map_err<F, E>(
self, self,
f: F, f: F,
) -> PipelineFactory<MapErrServiceFactory<T, R, F, E>, R> ) -> PipelineFactory<MapErrServiceFactory<T, R, C, F, E>, R, C>
where where
Self: Sized, Self: Sized,
F: Fn(T::Error) -> E + Clone, F: Fn(T::Error) -> E + Clone,
@ -301,7 +299,10 @@ impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> {
} }
/// Map this factory's init error to a different error, returning a new service. /// Map this factory's init error to a different error, returning a new service.
pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, R, F, E>, R> pub fn map_init_err<F, E>(
self,
f: F,
) -> PipelineFactory<MapInitErr<T, R, C, F, E>, R, C>
where where
Self: Sized, Self: Sized,
F: Fn(T::InitError) -> E + Clone, F: Fn(T::InitError) -> E + Clone,
@ -313,7 +314,7 @@ impl<T: ServiceFactory<R>, R> PipelineFactory<T, R> {
} }
} }
impl<T, R> Clone for PipelineFactory<T, R> impl<T, R, C> Clone for PipelineFactory<T, R, C>
where where
T: Clone, T: Clone,
{ {
@ -325,8 +326,7 @@ where
} }
} }
impl<T: ServiceFactory<R>, R> ServiceFactory<R> for PipelineFactory<T, R> { impl<T: ServiceFactory<R, C>, R, C> ServiceFactory<R, C> for PipelineFactory<T, R, C> {
type Config = T::Config;
type Response = T::Response; type Response = T::Response;
type Error = T::Error; type Error = T::Error;
type Service = T::Service; type Service = T::Service;
@ -334,7 +334,7 @@ impl<T: ServiceFactory<R>, R> ServiceFactory<R> for PipelineFactory<T, R> {
type Future = T::Future; type Future = T::Future;
#[inline] #[inline]
fn new_service(&self, cfg: T::Config) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
self.factory.new_service(cfg) self.factory.new_service(cfg)
} }
} }

49
ntex-service/src/then.rs
View file

@ -129,30 +129,20 @@ where
/// `.then()` service factory combinator /// `.then()` service factory combinator
pub struct ThenFactory<A, B, R>(Rc<(A, B)>, PhantomData<R>); pub struct ThenFactory<A, B, R>(Rc<(A, B)>, PhantomData<R>);
impl<A, B, R> ThenFactory<A, B, R> impl<A, B, R> ThenFactory<A, B, R> {
where
A: ServiceFactory<R>,
A::Config: Clone,
B: ServiceFactory<
Result<A::Response, A::Error>,
Config = A::Config,
Error = A::Error,
InitError = A::InitError,
>,
{
/// Create new `AndThen` combinator /// Create new `AndThen` combinator
pub(crate) fn new(a: A, b: B) -> Self { pub(crate) fn new(a: A, b: B) -> Self {
Self(Rc::new((a, b)), PhantomData) Self(Rc::new((a, b)), PhantomData)
} }
} }
impl<A, B, R> ServiceFactory<R> for ThenFactory<A, B, R> impl<A, B, R, C> ServiceFactory<R, C> for ThenFactory<A, B, R>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
A::Config: Clone, C: Clone,
B: ServiceFactory< B: ServiceFactory<
Result<A::Response, A::Error>, Result<A::Response, A::Error>,
Config = A::Config, C,
Error = A::Error, Error = A::Error,
InitError = A::InitError, InitError = A::InitError,
>, >,
@ -160,17 +150,13 @@ where
type Response = B::Response; type Response = B::Response;
type Error = A::Error; type Error = A::Error;
type Config = A::Config;
type Service = Then<A::Service, B::Service, R>; type Service = Then<A::Service, B::Service, R>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = ThenServiceFactoryResponse<A, B, R>; type Future = ThenFactoryResponse<A, B, R, C>;
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
let srv = &*self.0; let srv = &*self.0;
ThenServiceFactoryResponse::new( ThenFactoryResponse::new(srv.0.new_service(cfg.clone()), srv.1.new_service(cfg))
srv.0.new_service(cfg.clone()),
srv.1.new_service(cfg),
)
} }
} }
@ -181,11 +167,10 @@ impl<A, B, R> Clone for ThenFactory<A, B, R> {
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct ThenServiceFactoryResponse<A, B, R> pub struct ThenFactoryResponse<A, B, R, C>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
B: ServiceFactory<Result<A::Response, A::Error>, B: ServiceFactory<Result<A::Response, A::Error>, C,
Config = A::Config,
Error = A::Error, Error = A::Error,
InitError = A::InitError, InitError = A::InitError,
>, >,
@ -199,12 +184,12 @@ pin_project_lite::pin_project! {
} }
} }
impl<A, B, R> ThenServiceFactoryResponse<A, B, R> impl<A, B, R, C> ThenFactoryResponse<A, B, R, C>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
B: ServiceFactory< B: ServiceFactory<
Result<A::Response, A::Error>, Result<A::Response, A::Error>,
Config = A::Config, C,
Error = A::Error, Error = A::Error,
InitError = A::InitError, InitError = A::InitError,
>, >,
@ -219,12 +204,12 @@ where
} }
} }
impl<A, B, R> Future for ThenServiceFactoryResponse<A, B, R> impl<A, B, R, C> Future for ThenFactoryResponse<A, B, R, C>
where where
A: ServiceFactory<R>, A: ServiceFactory<R, C>,
B: ServiceFactory< B: ServiceFactory<
Result<A::Response, A::Error>, Result<A::Response, A::Error>,
Config = A::Config, C,
Error = A::Error, Error = A::Error,
InitError = A::InitError, InitError = A::InitError,
>, >,

33
ntex-service/src/transform.rs
View file

@ -5,11 +5,11 @@ use std::{
use crate::{IntoServiceFactory, Service, ServiceFactory}; use crate::{IntoServiceFactory, Service, ServiceFactory};
/// Apply transform to a service. /// Apply transform to a service.
pub fn apply<T, S, R, U>(t: T, factory: U) -> ApplyTransform<T, S, R> pub fn apply<T, S, R, C, U>(t: T, factory: U) -> ApplyTransform<T, S, R, C>
where where
S: ServiceFactory<R>, S: ServiceFactory<R, C>,
T: Transform<S::Service>, T: Transform<S::Service>,
U: IntoServiceFactory<S, R>, U: IntoServiceFactory<S, R, C>,
{ {
ApplyTransform::new(t, factory.into_factory()) ApplyTransform::new(t, factory.into_factory())
} }
@ -101,11 +101,11 @@ where
} }
/// `Apply` transform to new service /// `Apply` transform to new service
pub struct ApplyTransform<T, S, R>(Rc<(T, S)>, PhantomData<R>); pub struct ApplyTransform<T, S, R, C>(Rc<(T, S)>, PhantomData<(R, C)>);
impl<T, S, R> ApplyTransform<T, S, R> impl<T, S, R, C> ApplyTransform<T, S, R, C>
where where
S: ServiceFactory<R>, S: ServiceFactory<R, C>,
T: Transform<S::Service>, T: Transform<S::Service>,
{ {
/// Create new `ApplyTransform` new service instance /// Create new `ApplyTransform` new service instance
@ -114,49 +114,50 @@ where
} }
} }
impl<T, S, R> Clone for ApplyTransform<T, S, R> { impl<T, S, R, C> Clone for ApplyTransform<T, S, R, C> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
ApplyTransform(self.0.clone(), PhantomData) ApplyTransform(self.0.clone(), PhantomData)
} }
} }
impl<T, S, R> ServiceFactory<R> for ApplyTransform<T, S, R> impl<T, S, R, C> ServiceFactory<R, C> for ApplyTransform<T, S, R, C>
where where
S: ServiceFactory<R>, S: ServiceFactory<R, C>,
T: Transform<S::Service>, T: Transform<S::Service>,
T::Service: Service<R>, T::Service: Service<R>,
{ {
type Response = <T::Service as Service<R>>::Response; type Response = <T::Service as Service<R>>::Response;
type Error = <T::Service as Service<R>>::Error; type Error = <T::Service as Service<R>>::Error;
type Config = S::Config;
type Service = T::Service; type Service = T::Service;
type InitError = S::InitError; type InitError = S::InitError;
type Future = ApplyTransformFuture<T, S, R>; type Future = ApplyTransformFuture<T, S, R, C>;
fn new_service(&self, cfg: S::Config) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
ApplyTransformFuture { ApplyTransformFuture {
store: self.0.clone(), store: self.0.clone(),
fut: self.0.as_ref().1.new_service(cfg), fut: self.0.as_ref().1.new_service(cfg),
_t: PhantomData,
} }
} }
} }
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
pub struct ApplyTransformFuture<T, S, R> pub struct ApplyTransformFuture<T, S, R, C>
where where
S: ServiceFactory<R>, S: ServiceFactory<R, C>,
T: Transform<S::Service>, T: Transform<S::Service>,
{ {
store: Rc<(T, S)>, store: Rc<(T, S)>,
#[pin] #[pin]
fut: S::Future, fut: S::Future,
_t: PhantomData<C>
} }
} }
impl<T, S, R> Future for ApplyTransformFuture<T, S, R> impl<T, S, R, C> Future for ApplyTransformFuture<T, S, R, C>
where where
S: ServiceFactory<R>, S: ServiceFactory<R, C>,
T: Transform<S::Service>, T: Transform<S::Service>,
{ {
type Output = Result<T::Service, S::InitError>; type Output = Result<T::Service, S::InitError>;