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

Use pin-project-lite instead of pin-project

Browse source
This commit is contained in:
Nikolay Kim 2021-01-13 01:36:01 +06:00
parent 3987fbe508
commit c0d0c2b088
8 changed files with 224 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex-service/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.1.5] - 2021-01-13
* Use pin-project-lite instead of pin-project
## [0.1.4] - 2020-09-24
* Add `fn_transform` fn, allows to use function as transform service

7
ntex-service/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-service"
version = "0.1.4"
version = "0.1.5"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntex service"
keywords = ["network", "framework", "async", "futures"]
@ -16,9 +16,8 @@ name = "ntex_service"
path = "src/lib.rs"
[dependencies]
futures-util = "0.3.5"
pin-project = "0.4.20"
pin-project-lite = "0.1.5"
futures-util = "0.3.9"
pin-project-lite = "0.2.4"
[dev-dependencies]
ntex-rt = "0.1"

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

@ -63,31 +63,36 @@ where
#[inline]
fn call(&self, req: A::Request) -> Self::Future {
AndThenServiceResponse {
state: State::A(self.0.as_ref().0.call(req), Some(self.0.clone())),
state: State::A {
fut: self.0.as_ref().0.call(req),
b: Some(self.0.clone()),
},
}
}
}
pin_project_lite::pin_project! {
pub(crate) struct AndThenServiceResponse<A, B>
where
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
#[pin]
state: State<A, B>,
}
pub(crate) struct AndThenServiceResponse<A, B>
where
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
#[pin]
state: State<A, B>,
}
}
#[pin_project::pin_project(project = StateProject)]
enum State<A, B>
where
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
A(#[pin] A::Future, Option<Rc<(A, B)>>),
B(#[pin] B::Future),
Empty,
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<A, B>
where
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
A { #[pin] fut: A::Future, b: Option<Rc<(A, B)>> },
B { #[pin] fut: B::Future },
Empty,
}
}
impl<A, B> Future for AndThenServiceResponse<A, B>
@ -101,17 +106,17 @@ where
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A(fut, b) => match fut.poll(cx)? {
StateProject::A { fut, b } => match fut.poll(cx)? {
Poll::Ready(res) => {
let b = b.take().unwrap();
this.state.set(State::Empty); // drop fut A
let fut = b.as_ref().1.call(res);
this.state.set(State::B(fut));
this.state.set(State::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::B(fut) => fut.poll(cx).map(|r| {
StateProject::B { fut } => fut.poll(cx).map(|r| {
this.state.set(State::Empty);
r
}),
@ -204,19 +209,19 @@ where
}
pin_project_lite::pin_project! {
pub(crate) struct AndThenServiceFactoryResponse<A, B>
where
A: ServiceFactory,
B: ServiceFactory<Request = A::Response>,
{
#[pin]
fut_a: A::Future,
#[pin]
fut_b: B::Future,
pub(crate) struct AndThenServiceFactoryResponse<A, B>
where
A: ServiceFactory,
B: ServiceFactory<Request = A::Response>,
{
#[pin]
fut_a: A::Future,
#[pin]
fut_b: B::Future,
a: Option<A::Service>,
b: Option<B::Service>,
}
a: Option<A::Service>,
b: Option<B::Service>,
}
}
impl<A, B> AndThenServiceFactoryResponse<A, B>

97
ntex-service/src/and_then_apply_fn.rs
View file

@ -90,39 +90,44 @@ where
fn call(&self, req: A::Request) -> Self::Future {
let fut = self.srv.as_ref().0.call(req);
AndThenApplyFnFuture {
state: State::A(fut, Some(self.srv.clone())),
state: State::A {
fut,
b: Some(self.srv.clone()),
},
}
}
}
pin_project_lite::pin_project! {
pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
where
A: Service,
B: Service,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
#[pin]
state: State<A, B, F, Fut, Res, Err>,
}
pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
where
A: Service,
B: Service,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
#[pin]
state: State<A, B, F, Fut, Res, Err>,
}
}
#[pin_project::pin_project(project = StateProject)]
enum State<A, B, F, Fut, Res, Err>
where
A: Service,
B: Service,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
A(#[pin] A::Future, Option<Rc<(A, B, F)>>),
B(#[pin] Fut),
Empty,
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<A, B, F, Fut, Res, Err>
where
A: Service,
B: Service,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
A { #[pin] fut: A::Future, b: Option<Rc<(A, B, F)>> },
B { #[pin] fut: Fut },
Empty,
}
}
impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
@ -139,18 +144,18 @@ where
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A(fut, b) => match fut.poll(cx)? {
StateProject::A { fut, b } => match fut.poll(cx)? {
Poll::Ready(res) => {
let b = b.take().unwrap();
this.state.set(State::Empty);
let b = b.as_ref();
let fut = (&b.2)(res, &b.1);
this.state.set(State::B(fut));
this.state.set(State::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::B(fut) => fut.poll(cx).map(|r| {
StateProject::B { fut } => fut.poll(cx).map(|r| {
this.state.set(State::Empty);
r
}),
@ -224,23 +229,23 @@ where
}
pin_project_lite::pin_project! {
pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: Fn(A::Response, &B::Service) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
#[pin]
fut_b: B::Future,
#[pin]
fut_a: A::Future,
f: F,
a: Option<A::Service>,
b: Option<B::Service>,
}
pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: Fn(A::Response, &B::Service) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
#[pin]
fut_b: B::Future,
#[pin]
fut_a: A::Future,
f: F,
a: Option<A::Service>,
b: Option<B::Service>,
}
}
impl<A, B, F, Fut, Res, Err> Future

64
ntex-service/src/apply_cfg.rs
View file

@ -155,38 +155,42 @@ where
ApplyConfigServiceFactoryResponse {
cfg: Some(cfg),
store: self.srv.clone(),
state: State::A(self.srv.as_ref().0.new_service(())),
state: State::A {
fut: self.srv.as_ref().0.new_service(()),
},
}
}
}
pin_project_lite::pin_project! {
struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
where
F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
cfg: Option<C>,
store: Rc<(T, F)>,
#[pin]
state: State<T, R, S>,
}
struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
where
F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
cfg: Option<C>,
store: Rc<(T, F)>,
#[pin]
state: State<T, R, S>,
}
}
#[pin_project::pin_project(project = StateProject)]
enum State<T, R, S>
where
T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
A(#[pin] T::Future),
B(T::Service),
C(#[pin] R),
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<T, R, S>
where
T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
A { #[pin] fut: T::Future },
B { srv: T::Service },
C { #[pin] fut: R },
}
}
impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S>
@ -203,22 +207,22 @@ where
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A(fut) => match fut.poll(cx)? {
StateProject::A { fut } => match fut.poll(cx)? {
Poll::Pending => Poll::Pending,
Poll::Ready(srv) => {
this.state.set(State::B(srv));
this.state.set(State::B { srv });
self.poll(cx)
}
},
StateProject::B(srv) => match srv.poll_ready(cx)? {
StateProject::B { srv } => match srv.poll_ready(cx)? {
Poll::Ready(_) => {
let fut = (this.store.as_ref().1)(this.cfg.take().unwrap(), srv);
this.state.set(State::C(fut));
this.state.set(State::C { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::C(fut) => fut.poll(cx),
StateProject::C { fut } => fut.poll(cx),
}
}
}

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

@ -224,31 +224,35 @@ where
MapConfigServiceResponse {
inner,
config: Some(cfg),
state: ResponseState::CreateMapper(self.0.m.new_service(())),
state: ResponseState::CreateMapper {
fut: self.0.m.new_service(()),
},
}
}
}
}
pin_project_lite::pin_project! {
pub struct MapConfigServiceResponse<A, M: ServiceFactory, C>
where
A: ServiceFactory,
M: ServiceFactory,
{
inner: Rc<Inner<A, M, C>>,
config: Option<C>,
#[pin]
state: ResponseState<A, M>,
}
pub struct MapConfigServiceResponse<A, M: ServiceFactory, C>
where
A: ServiceFactory,
M: ServiceFactory,
{
inner: Rc<Inner<A, M, C>>,
config: Option<C>,
#[pin]
state: ResponseState<A, M>,
}
}
#[pin_project::pin_project(project = ResponseStateProject)]
enum ResponseState<A: ServiceFactory, M: ServiceFactory> {
CreateMapper(#[pin] M::Future),
MapReady,
MapConfig(#[pin] <M::Service as Service>::Future),
CreateService(#[pin] A::Future),
pin_project_lite::pin_project! {
#[project = ResponseStateProject]
enum ResponseState<A: ServiceFactory, M: ServiceFactory> {
CreateMapper { #[pin] fut: M::Future },
MapReady,
MapConfig { #[pin] fut: <M::Service as Service>::Future },
CreateService { #[pin] fut: A::Future },
}
}
impl<A, M, C> Future for MapConfigServiceResponse<A, M, C>
@ -268,7 +272,7 @@ where
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
ResponseStateProject::CreateMapper(fut) => {
ResponseStateProject::CreateMapper { fut } => {
let mapper = ready!(fut.poll(cx))?;
*this.inner.mapper.borrow_mut() = Some(mapper);
this.state.set(ResponseState::MapReady);
@ -278,17 +282,17 @@ where
let mapper = this.inner.mapper.borrow();
ready!(mapper.as_ref().unwrap().poll_ready(cx))?;
let fut = mapper.as_ref().unwrap().call(this.config.take().unwrap());
this.state.set(ResponseState::MapConfig(fut));
this.state.set(ResponseState::MapConfig { fut });
drop(mapper);
self.poll(cx)
}
ResponseStateProject::MapConfig(fut) => {
ResponseStateProject::MapConfig { fut } => {
let config = ready!(fut.poll(cx))?;
let fut = this.inner.a.new_service(config);
this.state.set(ResponseState::CreateService(fut));
this.state.set(ResponseState::CreateService { fut });
self.poll(cx)
}
ResponseStateProject::CreateService(fut) => fut.poll(cx),
ResponseStateProject::CreateService { fut } => fut.poll(cx),
}
}
}

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

@ -62,31 +62,36 @@ where
fn call(&self, req: A::Request) -> Self::Future {
ThenServiceResponse {
state: State::A(self.0.as_ref().0.call(req), Some(self.0.clone())),
state: State::A {
fut: self.0.as_ref().0.call(req),
b: Some(self.0.clone()),
},
}
}
}
pin_project_lite::pin_project! {
pub(crate) struct ThenServiceResponse<A, B>
where
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
#[pin]
state: State<A, B>,
}
pub(crate) struct ThenServiceResponse<A, B>
where
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
#[pin]
state: State<A, B>,
}
}
#[pin_project::pin_project(project = StateProject)]
enum State<A, B>
where
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
A(#[pin] A::Future, Option<Rc<(A, B)>>),
B(#[pin] B::Future),
Empty,
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<A, B>
where
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
A { #[pin] fut: A::Future, b: Option<Rc<(A, B)>> },
B { #[pin] fut: B::Future },
Empty,
}
}
impl<A, B> Future for ThenServiceResponse<A, B>
@ -100,17 +105,17 @@ where
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A(fut, b) => match fut.poll(cx) {
StateProject::A { fut, b } => match fut.poll(cx) {
Poll::Ready(res) => {
let b = b.take().unwrap();
this.state.set(State::Empty); // drop fut A
let fut = b.as_ref().1.call(res);
this.state.set(State::B(fut));
this.state.set(State::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::B(fut) => fut.poll(cx).map(|r| {
StateProject::B { fut } => fut.poll(cx).map(|r| {
this.state.set(State::Empty);
r
}),
@ -177,23 +182,23 @@ impl<A, B> Clone for ThenServiceFactory<A, B> {
}
pin_project_lite::pin_project! {
pub(crate) struct ThenServiceFactoryResponse<A, B>
where
A: ServiceFactory,
B: ServiceFactory<
Config = A::Config,
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{
#[pin]
fut_b: B::Future,
#[pin]
fut_a: A::Future,
a: Option<A::Service>,
b: Option<B::Service>,
}
pub(crate) struct ThenServiceFactoryResponse<A, B>
where
A: ServiceFactory,
B: ServiceFactory<
Config = A::Config,
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{
#[pin]
fut_b: B::Future,
#[pin]
fut_a: A::Future,
a: Option<A::Service>,
b: Option<B::Service>,
}
}
impl<A, B> ThenServiceFactoryResponse<A, B>

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

@ -178,31 +178,35 @@ where
fn new_service(&self, cfg: S::Config) -> Self::Future {
ApplyTransformFuture {
store: self.0.clone(),
state: ApplyTransformFutureState::A(self.0.as_ref().1.new_service(cfg)),
state: ApplyTransformFutureState::A {
fut: self.0.as_ref().1.new_service(cfg),
},
}
}
}
pin_project_lite::pin_project! {
pub struct ApplyTransformFuture<T, S>
where
S: ServiceFactory,
T: Transform<S::Service, InitError = S::InitError>,
{
store: Rc<(T, S)>,
#[pin]
state: ApplyTransformFutureState<T, S>,
}
pub struct ApplyTransformFuture<T, S>
where
S: ServiceFactory,
T: Transform<S::Service, InitError = S::InitError>,
{
store: Rc<(T, S)>,
#[pin]
state: ApplyTransformFutureState<T, S>,
}
}
#[pin_project::pin_project(project = ApplyTransformFutureStateProject)]
pub enum ApplyTransformFutureState<T, S>
where
S: ServiceFactory,
T: Transform<S::Service, InitError = S::InitError>,
{
A(#[pin] S::Future),
B(#[pin] T::Future),
pin_project_lite::pin_project! {
#[project = ApplyTransformFutureStateProject]
pub enum ApplyTransformFutureState<T, S>
where
S: ServiceFactory,
T: Transform<S::Service, InitError = S::InitError>,
{
A { #[pin] fut: S::Future },
B { #[pin] fut: T::Future },
}
}
impl<T, S> Future for ApplyTransformFuture<T, S>
@ -216,15 +220,15 @@ where
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
ApplyTransformFutureStateProject::A(fut) => match fut.poll(cx)? {
ApplyTransformFutureStateProject::A { fut } => match fut.poll(cx)? {
Poll::Ready(srv) => {
let fut = this.store.0.new_transform(srv);
this.state.set(ApplyTransformFutureState::B(fut));
this.state.set(ApplyTransformFutureState::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
ApplyTransformFutureStateProject::B(fut) => fut.poll(cx),
ApplyTransformFutureStateProject::B { fut } => fut.poll(cx),
}
}
}