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

Revert "Make AndThenFactory::new() public, cleanups"

Browse source 
This reverts commit 4a642901a1.
This commit is contained in:
Nikolay Kim 2022-07-07 21:54:44 +06:00
parent 1ac4a636b3
commit f1bffbbe52
6 changed files with 86 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex-service/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-service"
version = "0.3.2"
version = "0.3.1"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntex service"
keywords = ["network", "framework", "async", "futures"]
@ -20,4 +20,4 @@ pin-project-lite = "0.2.6"
[dev-dependencies]
ntex = { version = "0.5", features = ["tokio"] }
ntex-util = "0.1.13"
ntex-util = "0.1.5"

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

@ -126,20 +126,27 @@ where
}
/// `.and_then()` service factory combinator
pub struct AndThenFactory<A, B> {
pub struct AndThenFactory<A, B, Req, Cfg> {
inner: Rc<(A, B)>,
_t: PhantomData<fn(Req, Cfg)>,
}
impl<A, B> AndThenFactory<A, B> {
impl<A, B, Req, Cfg> AndThenFactory<A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
Cfg: Clone,
{
/// Create new `AndThenFactory` combinator
pub fn new(a: A, b: B) -> Self {
pub(crate) fn new(a: A, b: B) -> Self {
Self {
inner: Rc::new((a, b)),
_t: PhantomData,
}
}
}
impl<A, B, Req, Cfg> ServiceFactory<Req, Cfg> for AndThenFactory<A, B>
impl<A, B, Req, Cfg> ServiceFactory<Req, Cfg> for AndThenFactory<A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
@ -150,27 +157,28 @@ where
type Service = AndThen<A::Service, B::Service, Req>;
type InitError = A::InitError;
type Future = AndThenFactoryResponse<A, B, Req, Cfg>;
type Future = AndThenServiceFactoryResponse<A, B, Req, Cfg>;
fn new_service(&self, cfg: Cfg) -> Self::Future {
let inner = &*self.inner;
AndThenFactoryResponse::new(
AndThenServiceFactoryResponse::new(
inner.0.new_service(cfg.clone()),
inner.1.new_service(cfg),
)
}
}
impl<A, B> Clone for AndThenFactory<A, B> {
impl<A, B, Req, Cfg> Clone for AndThenFactory<A, B, Req, Cfg> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
_t: PhantomData,
}
}
}
pin_project_lite::pin_project! {
pub struct AndThenFactoryResponse<A, B, Req, Cfg>
pub struct AndThenServiceFactoryResponse<A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Cfg>,
@ -185,13 +193,13 @@ pin_project_lite::pin_project! {
}
}
impl<A, B, Req, Cfg> AndThenFactoryResponse<A, B, Req, Cfg>
impl<A, B, Req, Cfg> AndThenServiceFactoryResponse<A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Cfg>,
{
fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
AndThenFactoryResponse {
AndThenServiceFactoryResponse {
fut_a,
fut_b,
a: None,
@ -200,7 +208,7 @@ where
}
}
impl<A, B, Req, Cfg> Future for AndThenFactoryResponse<A, B, Req, Cfg>
impl<A, B, Req, Cfg> Future for AndThenServiceFactoryResponse<A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,

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

@ -135,7 +135,7 @@ pub trait Service<Req> {
///
/// Note that this function consumes the receiving service and returns a
/// wrapped version of it.
fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, Req, F, E>
where
Self: Sized,
F: Fn(Self::Error) -> E,
@ -185,17 +185,23 @@ pub trait ServiceFactory<Req, Cfg = ()> {
#[inline]
/// 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, Cfg, F, E>
fn map_err<F, E>(
self,
f: F,
) -> crate::map_err::MapErrServiceFactory<Self, Req, Cfg, F, E>
where
Self: Sized,
F: Fn(Self::Error) -> E + Clone,
{
crate::map_err::MapErrServiceFactory::new(self, f)
crate::map_err::MapErrServiceFactory::<_, _, Cfg, _, _>::new(self, f)
}
#[inline]
/// 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, F, E>
fn map_init_err<F, E>(
self,
f: F,
) -> crate::map_init_err::MapInitErr<Self, Req, Cfg, F, E>
where
Self: Sized,
F: Fn(Self::InitError) -> E + Clone,

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

@ -6,15 +6,19 @@ use super::{Service, ServiceFactory};
/// error.
///
/// This is created by the `ServiceExt::map_err` method.
pub struct MapErr<A, F, E> {
pub struct MapErr<A, R, F, E> {
service: A,
f: F,
_t: PhantomData<E>,
_t: PhantomData<fn(R) -> E>,
}
impl<A, F, E> MapErr<A, F, E> {
impl<A, R, F, E> MapErr<A, R, F, E> {
/// Create new `MapErr` combinator
pub(crate) fn new(service: A, f: F) -> Self {
pub(crate) fn new(service: A, f: F) -> Self
where
A: Service<R>,
F: Fn(A::Error) -> E,
{
Self {
service,
f,
@ -23,7 +27,7 @@ impl<A, F, E> MapErr<A, F, E> {
}
}
impl<A, F, E> Clone for MapErr<A, F, E>
impl<A, R, F, E> Clone for MapErr<A, R, F, E>
where
A: Clone,
F: Clone,
@ -38,7 +42,7 @@ where
}
}
impl<A, R, F, E> Service<R> for MapErr<A, F, E>
impl<A, R, F, E> Service<R> for MapErr<A, R, F, E>
where
A: Service<R>,
F: Fn(A::Error) -> E + Clone,
@ -102,13 +106,21 @@ where
/// service's error.
///
/// This is created by the `NewServiceExt::map_err` method.
pub struct MapErrServiceFactory<A, C, F, E> {
pub struct MapErrServiceFactory<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
a: A,
f: F,
e: PhantomData<(C, E)>,
e: PhantomData<fn(R, C) -> E>,
}
impl<A, C, F, E> MapErrServiceFactory<A, C, F, E> {
impl<A, R, C, F, E> MapErrServiceFactory<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
/// Create new `MapErr` new service instance
pub(crate) fn new(a: A, f: F) -> Self {
Self {
@ -119,10 +131,10 @@ impl<A, C, F, E> MapErrServiceFactory<A, C, F, E> {
}
}
impl<A, C, F, E> Clone for MapErrServiceFactory<A, C, F, E>
impl<A, R, C, F, E> Clone for MapErrServiceFactory<A, R, C, F, E>
where
A: Clone,
F: Clone,
A: ServiceFactory<R, C> + Clone,
F: Fn(A::Error) -> E + Clone,
{
fn clone(&self) -> Self {
Self {
@ -133,7 +145,7 @@ where
}
}
impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, C, F, E>
impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
@ -141,7 +153,7 @@ where
type Response = A::Response;
type Error = E;
type Service = MapErr<A::Service, F, E>;
type Service = MapErr<A::Service, R, F, E>;
type InitError = A::InitError;
type Future = MapErrServiceFuture<A, R, C, F, E>;
@ -178,7 +190,7 @@ where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
type Output = Result<MapErr<A::Service, R, F, E>, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();

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

@ -3,13 +3,17 @@ use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Po
use super::ServiceFactory;
/// `MapInitErr` service combinator
pub struct MapInitErr<A, F, E> {
pub struct MapInitErr<A, R, C, F, E> {
a: A,
f: F,
e: PhantomData<E>,
e: PhantomData<fn(R, C) -> E>,
}
impl<A, F, E> MapInitErr<A, F, E> {
impl<A, R, C, F, E> MapInitErr<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
{
/// Create new `MapInitErr` combinator
pub(crate) fn new(a: A, f: F) -> Self {
Self {
@ -20,7 +24,7 @@ impl<A, F, E> MapInitErr<A, F, E> {
}
}
impl<A, F, E> Clone for MapInitErr<A, F, E>
impl<A, R, C, F, E> Clone for MapInitErr<A, R, C, F, E>
where
A: Clone,
F: Clone,
@ -34,7 +38,7 @@ where
}
}
impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, F, E>
impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E + Clone,
@ -44,7 +48,7 @@ where
type Service = A::Service;
type InitError = E;
type Future = MapInitErrFuture<A::Future, A::Service, A::InitError, F, E>;
type Future = MapInitErrFuture<A, R, C, F, E>;
fn new_service(&self, cfg: C) -> Self::Future {
MapInitErrFuture {
@ -55,23 +59,23 @@ where
}
pin_project_lite::pin_project! {
pub struct MapInitErrFuture<Fut, Srv, Err, F, E>
pub struct MapInitErrFuture<A, R, C, F, E>
where
F: Fn(Err) -> E,
Fut: Future<Output = Result<Srv, Err>>,
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
{
f: F,
#[pin]
fut: Fut,
fut: A::Future,
}
}
impl<Fut, Srv, Err, F, E> Future for MapInitErrFuture<Fut, Srv, Err, F, E>
impl<A, R, C, F, E> Future for MapInitErrFuture<A, R, C, F, E>
where
F: Fn(Err) -> E,
Fut: Future<Output = Result<Srv, Err>>,
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
{
type Output = Result<Srv, E>;
type Output = Result<A::Service, E>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();

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

@ -105,7 +105,7 @@ impl<T: Service<R>, R> Pipeline<T, R> {
///
/// Note that this function consumes the receiving service and returns a
/// wrapped version of it.
pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>, R>
pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, R, F, E>, R>
where
Self: Sized,
F: Fn(T::Error) -> E,
@ -158,7 +158,10 @@ pub struct PipelineFactory<T, R, C = ()> {
impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
/// Call another service after call to this one has resolved successfully.
pub fn and_then<F, U>(self, factory: F) -> PipelineFactory<AndThenFactory<T, U>, R, C>
pub fn and_then<F, U>(
self,
factory: F,
) -> PipelineFactory<AndThenFactory<T, U, R, C>, R, C>
where
Self: Sized,
C: Clone,
@ -228,7 +231,7 @@ impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
pub fn map_err<F, E>(
self,
f: F,
) -> PipelineFactory<MapErrServiceFactory<T, C, F, E>, R, C>
) -> PipelineFactory<MapErrServiceFactory<T, R, C, F, E>, R, C>
where
Self: Sized,
F: Fn(T::Error) -> E + Clone,
@ -240,7 +243,10 @@ impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
}
/// 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, F, E>, R, C>
pub fn map_init_err<F, E>(
self,
f: F,
) -> PipelineFactory<MapInitErr<T, R, C, F, E>, R, C>
where
Self: Sized,
F: Fn(T::InitError) -> E + Clone,