berkus
/
actix-net
mirror of https://github.com/fafhrd91/actix-net
1
0
Fork 0
Code Issues Releases Wiki Activity

drop IntoFuture trait

This commit is contained in:
Nikolay Kim 2019-11-11 13:35:35 +06:00
parent 68e00ec18c
commit ae40042ea7
6 changed files with 189 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
actix-service/src/apply.rs
View File

@ -4,28 +4,31 @@ use std::marker::PhantomData;
use std::pin::Pin;
use std::task::{Context, Poll};
use super::IntoFuture;
use super::{Factory, IntoFactory, IntoService, Service};
/// Apply tranform function to a service
pub fn apply_fn<T, F, In, Out, U>(service: U, f: F) -> Apply<T, F, In, Out>
pub fn apply_fn<T, F, R, In, Out, Err, U>(
service: U,
f: F,
) -> impl Service<Request = In, Response = Out, Error = Err>
where
T: Service,
F: FnMut(In, &mut T) -> Out,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R,
R: Future<Output = Result<Out, Err>>,
U: IntoService<T>,
{
Apply::new(service.into_service(), f)
}
/// Create factory for `apply` service.
pub fn apply_fn_factory<T, F, In, Out, U>(service: U, f: F) -> ApplyNewService<T, F, In, Out>
pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
service: U,
f: F,
) -> impl Factory<Request = In, Response = Out, Error = Err>
where
T: Factory,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Factory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>,
U: IntoFactory<T>,
{
ApplyNewService::new(service.into_factory(), f)
@ -34,25 +37,24 @@ where
#[doc(hidden)]
/// `Apply` service combinator
#[pin_project]
pub struct Apply<T, F, In, Out>
struct Apply<T, F, R, In, Out, Err>
where
T: Service,
T: Service<Error = Err>,
{
#[pin]
service: T,
f: F,
r: PhantomData<(In, Out)>,
r: PhantomData<(In, Out, R)>,
}
impl<T, F, In, Out> Apply<T, F, In, Out>
impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
where
T: Service,
F: FnMut(In, &mut T) -> Out,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R,
R: Future<Output = Result<Out, Err>>,
{
/// Create new `Apply` combinator
pub(crate) fn new(service: T, f: F) -> Self {
fn new(service: T, f: F) -> Self {
Self {
service,
f,
@ -61,60 +63,44 @@ where
}
}
impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
where
T: Service + Clone,
F: Clone,
{
fn clone(&self) -> Self {
Apply {
service: self.service.clone(),
f: self.f.clone(),
r: PhantomData,
}
}
}
impl<T, F, In, Out> Service for Apply<T, F, In, Out>
where
T: Service,
F: FnMut(In, &mut T) -> Out,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R,
R: Future<Output = Result<Out, Err>>,
{
type Request = In;
type Response = Out::Item;
type Error = Out::Error;
type Future = Out::Future;
type Response = Out;
type Error = Err;
type Future = R;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(futures::ready!(self.service.poll_ready(ctx)).map_err(|e| e.into()))
Poll::Ready(futures::ready!(self.service.poll_ready(ctx)))
}
fn call(&mut self, req: In) -> Self::Future {
(self.f)(req, &mut self.service).into_future()
(self.f)(req, &mut self.service)
}
}
/// `ApplyNewService` new service combinator
pub struct ApplyNewService<T, F, In, Out>
struct ApplyNewService<T, F, R, In, Out, Err>
where
T: Factory,
T: Factory<Error = Err>,
{
service: T,
f: F,
r: PhantomData<(In, Out)>,
r: PhantomData<(R, In, Out)>,
}
impl<T, F, In, Out> ApplyNewService<T, F, In, Out>
impl<T, F, R, In, Out, Err> ApplyNewService<T, F, R, In, Out, Err>
where
T: Factory,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Factory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>,
{
/// Create new `ApplyNewService` new service instance
pub(crate) fn new(service: T, f: F) -> Self {
fn new(service: T, f: F) -> Self {
Self {
f,
service,
@ -123,36 +109,20 @@ where
}
}
impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out>
impl<T, F, R, In, Out, Err> Factory for ApplyNewService<T, F, R, In, Out, Err>
where
T: Factory + Clone,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
{
fn clone(&self) -> Self {
Self {
service: self.service.clone(),
f: self.f.clone(),
r: PhantomData,
}
}
}
impl<T, F, In, Out> Factory for ApplyNewService<T, F, In, Out>
where
T: Factory,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Factory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>,
{
type Request = In;
type Response = Out::Item;
type Error = Out::Error;
type Response = Out;
type Error = Err;
type Config = T::Config;
type Service = Apply<T::Service, F, In, Out>;
type Service = Apply<T::Service, F, R, In, Out, Err>;
type InitError = T::InitError;
type Future = ApplyNewServiceFuture<T, F, In, Out>;
type Future = ApplyNewServiceFuture<T, F, R, In, Out, Err>;
fn new_service(&self, cfg: &T::Config) -> Self::Future {
ApplyNewServiceFuture::new(self.service.new_service(cfg), self.f.clone())
@ -160,11 +130,11 @@ where
}
#[pin_project]
pub struct ApplyNewServiceFuture<T, F, In, Out>
struct ApplyNewServiceFuture<T, F, R, In, Out, Err>
where
T: Factory,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
T: Factory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>,
{
#[pin]
fut: T::Future,
@ -172,11 +142,11 @@ where
r: PhantomData<(In, Out)>,
}
impl<T, F, In, Out> ApplyNewServiceFuture<T, F, In, Out>
impl<T, F, R, In, Out, Err> ApplyNewServiceFuture<T, F, R, In, Out, Err>
where
T: Factory,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
T: Factory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>,
{
fn new(fut: T::Future, f: F) -> Self {
ApplyNewServiceFuture {
@ -187,14 +157,13 @@ where
}
}
impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out>
impl<T, F, R, In, Out, Err> Future for ApplyNewServiceFuture<T, F, R, In, Out, Err>
where
T: Factory,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
T: Factory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>,
{
type Output = Result<Apply<T::Service, F, In, Out>, T::InitError>;
type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();

74
actix-service/src/apply_cfg.rs
View File

@ -7,10 +7,10 @@ use futures::ready;
use pin_project::pin_project;
use crate::cell::Cell;
use crate::{Factory, IntoFuture, IntoService, Service};
use crate::{Factory, IntoService, Service};
/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
pub fn apply_cfg<F, C, T, R, S>(
pub fn apply_cfg<F, C, T, R, S, E>(
srv: T,
f: F,
) -> impl Factory<
@ -19,18 +19,17 @@ pub fn apply_cfg<F, C, T, R, S>(
Response = S::Response,
Error = S::Error,
Service = S,
InitError = R::Error,
InitError = E,
> + Clone
where
F: FnMut(&C, &mut T) -> R,
T: Service,
R: IntoFuture,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
ApplyConfigService {
f: Cell::new(f),
srv: Cell::new(srv.into_service()),
srv: Cell::new(srv),
_t: PhantomData,
}
}
@ -53,8 +52,7 @@ where
F: FnMut(&C, &mut T::Service) -> R,
T: Factory<Config = ()>,
T::InitError: From<T::Error>,
R: IntoFuture<Error = T::InitError>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
ApplyConfigNewService {
@ -66,12 +64,11 @@ where
/// Convert `Fn(&Config) -> Future<Service>` fn to NewService\
#[pin_project]
struct ApplyConfigService<F, C, T, R, S>
struct ApplyConfigService<F, C, T, R, S, E>
where
F: FnMut(&C, &mut T) -> R,
T: Service,
R: IntoFuture,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
f: Cell<F>,
@ -80,12 +77,11 @@ where
_t: PhantomData<(C, R, S)>,
}
impl<F, C, T, R, S> Clone for ApplyConfigService<F, C, T, R, S>
impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E>
where
F: FnMut(&C, &mut T) -> R,
T: Service,
R: IntoFuture,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
fn clone(&self) -> Self {
@ -97,12 +93,11 @@ where
}
}
impl<F, C, T, R, S> Factory for ApplyConfigService<F, C, T, R, S>
impl<F, C, T, R, S, E> Factory for ApplyConfigService<F, C, T, R, S, E>
where
F: FnMut(&C, &mut T) -> R,
T: Service,
R: IntoFuture,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
type Config = C;
@ -111,37 +106,34 @@ where
type Error = S::Error;
type Service = S;
type InitError = R::Error;
type Future = FnNewServiceConfigFut<R, S>;
type InitError = E;
type Future = FnNewServiceConfigFut<R, S, E>;
fn new_service(&self, cfg: &C) -> Self::Future {
FnNewServiceConfigFut {
fut: unsafe { (self.f.get_mut_unsafe())(cfg, self.srv.get_mut_unsafe()) }
.into_future(),
fut: unsafe { (self.f.get_mut_unsafe())(cfg, self.srv.get_mut_unsafe()) },
_t: PhantomData,
}
}
}
#[pin_project]
struct FnNewServiceConfigFut<R, S>
struct FnNewServiceConfigFut<R, S, E>
where
R: IntoFuture,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
#[pin]
fut: R::Future,
fut: R,
_t: PhantomData<(S,)>,
}
impl<R, S> Future for FnNewServiceConfigFut<R, S>
impl<R, S, E> Future for FnNewServiceConfigFut<R, S, E>
where
R: IntoFuture,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
type Output = Result<S, R::Error>;
type Output = Result<S, E>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Poll::Ready(Ok(ready!(self.project().fut.poll(cx))?.into_service()))
@ -154,8 +146,7 @@ where
C: Clone,
F: FnMut(&C, &mut T::Service) -> R,
T: Factory<Config = ()>,
R: IntoFuture<Error = T::InitError>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
f: Cell<F>,
@ -168,8 +159,7 @@ where
C: Clone,
F: FnMut(&C, &mut T::Service) -> R,
T: Factory<Config = ()>,
R: IntoFuture<Error = T::InitError>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
fn clone(&self) -> Self {
@ -187,8 +177,7 @@ where
F: FnMut(&C, &mut T::Service) -> R,
T: Factory<Config = ()>,
T::InitError: From<T::Error>,
R: IntoFuture<Error = T::InitError>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
type Config = C;
@ -197,7 +186,7 @@ where
type Error = S::Error;
type Service = S;
type InitError = R::Error;
type InitError = T::InitError;
type Future = ApplyConfigNewServiceFut<F, C, T, R, S>;
fn new_service(&self, cfg: &C) -> Self::Future {
@ -219,8 +208,7 @@ where
F: FnMut(&C, &mut T::Service) -> R,
T: Factory<Config = ()>,
T::InitError: From<T::Error>,
R: IntoFuture<Error = T::InitError>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
cfg: C,
@ -229,7 +217,7 @@ where
#[pin]
srv_fut: Option<T::Future>,
#[pin]
fut: Option<R::Future>,
fut: Option<R>,
_t: PhantomData<(S,)>,
}
@ -239,11 +227,10 @@ where
F: FnMut(&C, &mut T::Service) -> R,
T: Factory<Config = ()>,
T::InitError: From<T::Error>,
R: IntoFuture<Error = T::InitError>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, T::InitError>>,
S: Service,
{
type Output = Result<S, R::Error>;
type Output = Result<S, T::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.project();
@ -264,8 +251,7 @@ where
} else if let Some(ref mut srv) = this.srv {
match srv.poll_ready(cx)? {
Poll::Ready(_) => {
this.fut
.set(Some(this.f.get_mut()(&this.cfg, srv).into_future()));
this.fut.set(Some(this.f.get_mut()(&this.cfg, srv)));
continue 'poll;
}
Poll::Pending => return Poll::Pending,

2
actix-service/src/boxed.rs
View File

@ -7,7 +7,7 @@ use std::task::{Context, Poll};
use futures::future::{err, ok, Either, Ready};
use futures::future::{FutureExt, LocalBoxFuture};
use crate::{Factory, IntoFuture, Service};
use crate::{Factory, Service};
pub type BoxedService<Req, Res, Err> = Box<
dyn Service<

236
actix-service/src/fn_service.rs
View File

@ -6,163 +6,154 @@ use std::task::{Context, Poll};
use futures::future::{ok, Ready};
use pin_project::pin_project;
use crate::IntoFuture;
use crate::{Factory, IntoFactory, IntoService, Service};
/// Create `NewService` for function that can act as a Service
pub fn service_fn<F, Req, Out, Cfg>(
/// Create `Factory` for function that can act as a Service
pub fn service_fn<F, Fut, Req, Res, Err, Cfg>(
f: F,
) -> impl Factory<
Config = Cfg,
Request = Req,
Response = Out::Item,
Error = Out::Error,
InitError = (),
>
) -> impl Factory<Config = Cfg, Request = Req, Response = Res, Error = Err, InitError = ()> + Clone
where
F: FnMut(Req) -> Out + Clone,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
NewServiceFn::new(f)
}
/// Create `Factory` for function that can produce services
pub fn factory_fn<F, C, R, S, E>(
pub fn service_fn_factory<S, F, Cfg, Fut, Err>(
f: F,
) -> impl Factory<
Config = C,
Config = Cfg,
Request = S::Request,
Response = S::Response,
Error = S::Error,
InitError = E,
Future = R::Future,
InitError = Err,
Future = Fut,
>
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
R::Item: IntoService<S>,
S: Service,
F: Fn() -> Fut,
Fut: Future<Output = Result<S, Err>>,
{
FnNewServiceNoConfig::new(f)
}
/// Create `NewService` for function that can produce services with configuration
pub fn new_service_cfg<F, C, R, S, E>(
/// Create `Factory` for function that can produce services with configuration
pub fn service_fn_config<F, Fut, Cfg, Srv, Err>(
f: F,
) -> impl Factory<
Config = C,
Request = S::Request,
Response = S::Response,
Error = S::Error,
InitError = E,
Config = Cfg,
Request = Srv::Request,
Response = Srv::Response,
Error = Srv::Error,
InitError = Err,
>
where
F: Fn(&C) -> R,
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
S: Service,
F: Fn(&Cfg) -> Fut,
Fut: Future<Output = Result<Srv, Err>>,
Srv: Service,
{
FnNewServiceConfig::new(f)
}
pub(crate) struct ServiceFn<F, Req, Out>
pub struct ServiceFn<F, Fut, Req, Res, Err>
where
F: FnMut(Req) -> Out,
Out: IntoFuture,
F: FnMut(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
{
f: F,
_t: PhantomData<Req>,
}
impl<F, Req, Out> ServiceFn<F, Req, Out>
impl<F, Fut, Req, Res, Err> ServiceFn<F, Fut, Req, Res, Err>
where
F: FnMut(Req) -> Out,
Out: IntoFuture,
F: FnMut(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
{
pub(crate) fn new(f: F) -> Self {
ServiceFn { f, _t: PhantomData }
}
}
impl<F, Req, Out> Clone for ServiceFn<F, Req, Out>
impl<F, Fut, Req, Res, Err> Clone for ServiceFn<F, Fut, Req, Res, Err>
where
F: FnMut(Req) -> Out + Clone,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
fn clone(&self) -> Self {
ServiceFn::new(self.f.clone())
}
}
impl<F, Req, Out> Service for ServiceFn<F, Req, Out>
impl<F, Fut, Req, Res, Err> Service for ServiceFn<F, Fut, Req, Res, Err>
where
F: FnMut(Req) -> Out,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
type Request = Req;
type Response = Out::Item;
type Error = Out::Error;
type Future = Out::Future;
type Response = Res;
type Error = Err;
type Future = Fut;
fn poll_ready(&mut self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: Req) -> Self::Future {
(self.f)(req).into_future()
(self.f)(req)
}
}
impl<F, Req, Out> IntoService<ServiceFn<F, Req, Out>> for F
impl<F, Fut, Req, Res, Err> IntoService<ServiceFn<F, Fut, Req, Res, Err>> for F
where
F: FnMut(Req) -> Out,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
fn into_service(self) -> ServiceFn<F, Req, Out> {
fn into_service(self) -> ServiceFn<F, Fut, Req, Res, Err> {
ServiceFn::new(self)
}
}
pub(crate) struct NewServiceFn<F, Req, Out, Cfg>
struct NewServiceFn<F, Fut, Req, Res, Err, Cfg>
where
F: FnMut(Req) -> Out,
Out: IntoFuture,
F: FnMut(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
{
f: F,
_t: PhantomData<(Req, Cfg)>,
}
impl<F, Req, Out, Cfg> NewServiceFn<F, Req, Out, Cfg>
impl<F, Fut, Req, Res, Err, Cfg> NewServiceFn<F, Fut, Req, Res, Err, Cfg>
where
F: FnMut(Req) -> Out + Clone,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
pub(crate) fn new(f: F) -> Self {
fn new(f: F) -> Self {
NewServiceFn { f, _t: PhantomData }
}
}
impl<F, Req, Out, Cfg> Clone for NewServiceFn<F, Req, Out, Cfg>
impl<F, Fut, Req, Res, Err, Cfg> Clone for NewServiceFn<F, Fut, Req, Res, Err, Cfg>
where
F: FnMut(Req) -> Out + Clone,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
fn clone(&self) -> Self {
NewServiceFn::new(self.f.clone())
}
}
impl<F, Req, Out, Cfg> Factory for NewServiceFn<F, Req, Out, Cfg>
impl<F, Fut, Req, Res, Err, Cfg> Factory for NewServiceFn<F, Fut, Req, Res, Err, Cfg>
where
F: FnMut(Req) -> Out + Clone,
Out: IntoFuture,
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
{
type Request = Req;
type Response = Out::Item;
type Error = Out::Error;
type Response = Res;
type Error = Err;
type Config = Cfg;
type Service = ServiceFn<F, Req, Out>;
type Service = ServiceFn<F, Fut, Req, Res, Err>;
type InitError = ();
type Future = Ready<Result<Self::Service, Self::InitError>>;
@ -171,118 +162,79 @@ where
}
}
impl<F, Req, Out, Cfg> IntoService<ServiceFn<F, Req, Out>> for NewServiceFn<F, Req, Out, Cfg>
where
F: FnMut(Req) -> Out + Clone,
Out: IntoFuture,
{
fn into_service(self) -> ServiceFn<F, Req, Out> {
ServiceFn::new(self.f.clone())
}
}
impl<F, Req, Out, Cfg> IntoFactory<NewServiceFn<F, Req, Out, Cfg>> for F
where
F: Fn(Req) -> Out + Clone,
Out: IntoFuture,
{
fn into_factory(self) -> NewServiceFn<F, Req, Out, Cfg> {
NewServiceFn::new(self)
}
}
/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
pub(crate) struct FnNewServiceConfig<F, C, R, S, E>
struct FnNewServiceConfig<F, Fut, Cfg, Srv, Err>
where
F: Fn(&C) -> R,
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
S: Service,
F: Fn(&Cfg) -> Fut,
Fut: Future<Output = Result<Srv, Err>>,
Srv: Service,
{
f: F,
_t: PhantomData<(C, R, S, E)>,
_t: PhantomData<(Fut, Cfg, Srv, Err)>,
}
impl<F, C, R, S, E> FnNewServiceConfig<F, C, R, S, E>
impl<F, Fut, Cfg, Srv, Err> FnNewServiceConfig<F, Fut, Cfg, Srv, Err>
where
F: Fn(&C) -> R,
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
S: Service,
F: Fn(&Cfg) -> Fut,
Fut: Future<Output = Result<Srv, Err>>,
Srv: Service,
{
pub fn new(f: F) -> Self {
FnNewServiceConfig { f, _t: PhantomData }
}
}
impl<F, C, R, S, E> Factory for FnNewServiceConfig<F, C, R, S, E>
impl<F, Fut, Cfg, Srv, Err> Factory for FnNewServiceConfig<F, Fut, Cfg, Srv, Err>
where
F: Fn(&C) -> R,
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
S: Service,
F: Fn(&Cfg) -> Fut,
Fut: Future<Output = Result<Srv, Err>>,
Srv: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Request = Srv::Request;
type Response = Srv::Response;
type Error = Srv::Error;
type Config = C;
type Service = S;
type InitError = E;
type Future = FnNewServiceConfigFut<R, S, E>;
type Config = Cfg;
type Service = Srv;
type InitError = Err;
type Future = FnNewServiceConfigFut<Fut, Srv, Err>;
fn new_service(&self, cfg: &C) -> Self::Future {
fn new_service(&self, cfg: &Cfg) -> Self::Future {
FnNewServiceConfigFut {
fut: (self.f)(cfg).into_future(),
fut: (self.f)(cfg),
_t: PhantomData,
}
}
}
#[pin_project]
pub(crate) struct FnNewServiceConfigFut<R, S, E>
struct FnNewServiceConfigFut<R, S, E>
where
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
#[pin]
fut: R::Future,
fut: R,
_t: PhantomData<(S,)>,
}
impl<R, S, E> Future for FnNewServiceConfigFut<R, S, E>
where
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
R: Future<Output = Result<S, E>>,
S: Service,
{
type Output = Result<S, R::Error>;
type Output = Result<S, E>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Poll::Ready(Ok(
futures::ready!(self.project().fut.poll(cx))?.into_service()
))
}
}
impl<F, C, R, S, E> Clone for FnNewServiceConfig<F, C, R, S, E>
where
F: Fn(&C) -> R + Clone,
R: IntoFuture<Error = E>,
R::Item: IntoService<S>,
S: Service,
{
fn clone(&self) -> Self {
Self::new(self.f.clone())
Poll::Ready(Ok(futures::ready!(self.project().fut.poll(cx))?))
}
}
/// Converter for `Fn() -> Future<Service>` fn
pub(crate) struct FnNewServiceNoConfig<F, C, R, S, E>
pub struct FnNewServiceNoConfig<F, C, R, S, E>
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
R: Future<Output = Result<S, E>>,
S: Service,
{
f: F,
@ -292,10 +244,10 @@ where
impl<F, C, R, S, E> FnNewServiceNoConfig<F, C, R, S, E>
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
R: Future<Output = Result<S, E>>,
S: Service,
{
pub fn new(f: F) -> Self {
fn new(f: F) -> Self {
FnNewServiceNoConfig { f, _t: PhantomData }
}
}
@ -303,7 +255,7 @@ where
impl<F, C, R, S, E> Factory for FnNewServiceNoConfig<F, C, R, S, E>
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
R: Future<Output = Result<S, E>>,
S: Service,
{
type Request = S::Request;
@ -312,17 +264,17 @@ where
type Service = S;
type Config = C;
type InitError = E;
type Future = R::Future;
type Future = R;
fn new_service(&self, _: &C) -> Self::Future {
(self.f)().into_future()
(self.f)()
}
}
impl<F, C, R, S, E> Clone for FnNewServiceNoConfig<F, C, R, S, E>
where
F: Fn() -> R + Clone,
R: IntoFuture<Item = S, Error = E>,
R: Future<Output = Result<S, E>>,
S: Service,
{
fn clone(&self) -> Self {
@ -333,7 +285,7 @@ where
impl<F, C, R, S, E> IntoFactory<FnNewServiceNoConfig<F, C, R, S, E>> for F
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
R: Future<Output = Result<S, E>>,
S: Service,
{
fn into_factory(self) -> FnNewServiceNoConfig<F, C, R, S, E> {

46
actix-service/src/lib.rs
View File

@ -22,29 +22,12 @@ mod transform_err;
pub use self::apply::{apply_fn, apply_fn_factory};
pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
pub use self::fn_service::{factory_fn, new_service_cfg, service_fn};
pub use self::fn_service::{service_fn, service_fn_config, service_fn_factory};
pub use self::into::{into_factory, into_service, FactoryMapper, ServiceMapper};
pub use self::map_config::{map_config, unit_config, MappedConfig};
pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
pub use self::transform::{apply_transform, IntoTransform, Transform};
pub trait IntoFuture {
type Item;
type Error;
type Future: Future<Output = Result<Self::Item, Self::Error>>;
fn into_future(self) -> Self::Future;
}
impl<F: Future<Output = Result<I, E>>, I, E> IntoFuture for F {
type Item = I;
type Error = E;
type Future = F;
fn into_future(self) -> Self::Future {
self
}
}
/// An asynchronous function from `Request` to a `Response`.
pub trait Service {
/// Requests handled by the service.
@ -80,31 +63,6 @@ pub trait Service {
/// Calling `call` without calling `poll_ready` is permitted. The
/// implementation must be resilient to this fact.
fn call(&mut self, req: Self::Request) -> Self::Future;
// #[cfg(test)]
// fn poll_test(&mut self) -> Poll<Result<(), Self::Error>> {
// // kinda stupid method, but works for our test purposes
// unsafe {
// let mut this = Pin::new_unchecked(self);
// tokio::runtime::current_thread::Builder::new()
// .build()
// .unwrap()
// .block_on(futures::future::poll_fn(move |cx| {
// let this = &mut this;
// Poll::Ready(this.as_mut().poll_ready(cx))
// }))
// }
// }
// fn poll_once<'a>(&'a mut self) -> LocalBoxFuture<'a, Poll<Result<(), Self::Error>>> {
// unsafe {
// let mut this = Pin::new_unchecked(self);
// Pin::new_unchecked(Box::new(futures::future::poll_fn(move |cx| {
// //let this = &mut this;
// Poll::Ready(this.get_unchecked_mut().poll_ready(cx))
// })))
// }
// }
}
/// Creates new `Service` values.
@ -243,7 +201,7 @@ where
fn into_service(self) -> T;
}
/// Trait for types that can be converted to a `ServiceFactory`
/// Trait for types that can be converted to a `Factory`
pub trait IntoFactory<T>
where
T: Factory,

4
actix-service/src/map_config.rs
View File

@ -9,7 +9,7 @@ pub enum MappedConfig<'a, T> {
/// Adapt external config to a config for provided new service
pub fn map_config<T, F, C>(
new_service: T,
factory: T,
f: F,
) -> impl Factory<
Config = C,
@ -22,7 +22,7 @@ where
T: Factory,
F: Fn(&C) -> MappedConfig<T::Config>,
{
MapConfig::new(new_service, f)
MapConfig::new(factory, f)
}
/// Replace config with unit