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

Make AndThenFactory::new() public, cleanups

Browse source
This commit is contained in:
Nikolay Kim 2022-02-10 17:05:36 +06:00
parent 050cb560c6
commit 4a642901a1
7 changed files with 56 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

6
ntex-service/CHANGES.md
View file

@ -1,5 +1,11 @@
# Changes
## [0.3.2] - 2022-02-10
* Make AndThenFactory::new() public
* Cleanups
## [0.3.1] - 2022-01-03
* Do not depend on ntex-util

4
ntex-service/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-service"
version = "0.3.1"
version = "0.3.2"
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.5"
ntex-util = "0.1.13"

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

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

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

@ -6,19 +6,15 @@ use super::{Service, ServiceFactory};
/// error.
///
/// This is created by the `ServiceExt::map_err` method.
pub struct MapErr<A, R, F, E> {
pub struct MapErr<A, F, E> {
service: A,
f: F,
_t: PhantomData<fn(R) -> E>,
_t: PhantomData<E>,
}
impl<A, R, F, E> MapErr<A, R, F, E> {
impl<A, F, E> MapErr<A, F, E> {
/// Create new `MapErr` combinator
pub(crate) fn new(service: A, f: F) -> Self
where
A: Service<R>,
F: Fn(A::Error) -> E,
{
pub(crate) fn new(service: A, f: F) -> Self {
Self {
service,
f,
@ -27,7 +23,7 @@ impl<A, R, F, E> MapErr<A, R, F, E> {
}
}
impl<A, R, F, E> Clone for MapErr<A, R, F, E>
impl<A, F, E> Clone for MapErr<A, F, E>
where
A: Clone,
F: Clone,
@ -42,7 +38,7 @@ where
}
}
impl<A, R, F, E> Service<R> for MapErr<A, R, F, E>
impl<A, R, F, E> Service<R> for MapErr<A, F, E>
where
A: Service<R>,
F: Fn(A::Error) -> E + Clone,
@ -106,21 +102,13 @@ where
/// service's error.
///
/// This is created by the `NewServiceExt::map_err` method.
pub struct MapErrServiceFactory<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
pub struct MapErrServiceFactory<A, C, F, E> {
a: A,
f: F,
e: PhantomData<fn(R, C) -> E>,
e: PhantomData<(C, E)>,
}
impl<A, R, C, F, E> MapErrServiceFactory<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
impl<A, C, F, E> MapErrServiceFactory<A, C, F, E> {
/// Create new `MapErr` new service instance
pub(crate) fn new(a: A, f: F) -> Self {
Self {
@ -131,10 +119,10 @@ where
}
}
impl<A, R, C, F, E> Clone for MapErrServiceFactory<A, R, C, F, E>
impl<A, C, F, E> Clone for MapErrServiceFactory<A, C, F, E>
where
A: ServiceFactory<R, C> + Clone,
F: Fn(A::Error) -> E + Clone,
A: Clone,
F: Clone,
{
fn clone(&self) -> Self {
Self {
@ -145,7 +133,7 @@ where
}
}
impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, R, C, F, E>
impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
@ -153,7 +141,7 @@ where
type Response = A::Response;
type Error = E;
type Service = MapErr<A::Service, R, F, E>;
type Service = MapErr<A::Service, F, E>;
type InitError = A::InitError;
type Future = MapErrServiceFuture<A, R, C, F, E>;
@ -190,7 +178,7 @@ where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
type Output = Result<MapErr<A::Service, R, F, E>, A::InitError>;
type Output = Result<MapErr<A::Service, 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,17 +3,13 @@ use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Po
use super::ServiceFactory;
/// `MapInitErr` service combinator
pub struct MapInitErr<A, R, C, F, E> {
pub struct MapInitErr<A, F, E> {
a: A,
f: F,
e: PhantomData<fn(R, C) -> E>,
e: PhantomData<E>,
}
impl<A, R, C, F, E> MapInitErr<A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
{
impl<A, F, E> MapInitErr<A, F, E> {
/// Create new `MapInitErr` combinator
pub(crate) fn new(a: A, f: F) -> Self {
Self {
@ -24,7 +20,7 @@ where
}
}
impl<A, R, C, F, E> Clone for MapInitErr<A, R, C, F, E>
impl<A, F, E> Clone for MapInitErr<A, F, E>
where
A: Clone,
F: Clone,
@ -38,7 +34,7 @@ where
}
}
impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E + Clone,
@ -48,7 +44,7 @@ where
type Service = A::Service;
type InitError = E;
type Future = MapInitErrFuture<A, R, C, F, E>;
type Future = MapInitErrFuture<A::Future, A::Service, A::InitError, F, E>;
fn new_service(&self, cfg: C) -> Self::Future {
MapInitErrFuture {
@ -59,23 +55,23 @@ where
}
pin_project_lite::pin_project! {
pub struct MapInitErrFuture<A, R, C, F, E>
pub struct MapInitErrFuture<Fut, Srv, Err, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
F: Fn(Err) -> E,
Fut: Future<Output = Result<Srv, Err>>,
{
f: F,
#[pin]
fut: A::Future,
fut: Fut,
}
}
impl<A, R, C, F, E> Future for MapInitErrFuture<A, R, C, F, E>
impl<Fut, Srv, Err, F, E> Future for MapInitErrFuture<Fut, Srv, Err, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
F: Fn(Err) -> E,
Fut: Future<Output = Result<Srv, Err>>,
{
type Output = Result<A::Service, E>;
type Output = Result<Srv, 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, R, F, E>, R>
pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>, R>
where
Self: Sized,
F: Fn(T::Error) -> E,
@ -158,10 +158,7 @@ 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>, R, C>
pub fn and_then<F, U>(self, factory: F) -> PipelineFactory<AndThenFactory<T, U>, R, C>
where
Self: Sized,
C: Clone,
@ -231,7 +228,7 @@ impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
pub fn map_err<F, E>(
self,
f: F,
) -> PipelineFactory<MapErrServiceFactory<T, R, C, F, E>, R, C>
) -> PipelineFactory<MapErrServiceFactory<T, C, F, E>, R, C>
where
Self: Sized,
F: Fn(T::Error) -> E + Clone,
@ -243,10 +240,7 @@ 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, R, C, F, E>, R, C>
pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, E>, R, C>
where
Self: Sized,
F: Fn(T::InitError) -> E + Clone,