actix/actix-net
1
0
Fork 0
mirror of https://github.com/fafhrd91/actix-net synced 2025-06-26 22:07:42 +02:00
Code Issues Releases Wiki Activity

Use associated type instead of generic for Service definition

Browse Source
This commit is contained in:
Nikolay Kim
2019-02-01 19:53:13 -08:00
parent 8cdbf49187
commit d83bf95304
35 changed files with 544 additions and 421 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
actix-service/CHANGES.md
View File

@ -1,5 +1,30 @@
# Changes
## [0.2.0] - 2019-02-01
### Changed
* Use associated type instead of generic for Service definition.
* Before:
```rust
impl Service<Request> for Client {
type Response = Response;
// ...
}
```
* After:
```rust
impl Service for Client {
type Request = Request;
type Response = Response;
// ...
}
```
## [0.1.6] - 2019-01-24
### Changed

4
actix-service/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "actix-service"
version = "0.1.6"
version = "0.2.0"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
description = "Actix Service"
keywords = ["network", "framework", "async", "futures"]
@ -15,7 +15,7 @@ workspace = "../"
[badges]
travis-ci = { repository = "actix/actix-service", branch = "master" }
# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
appveyor = { repository = "actix/actix-net" }
codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
[lib]

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

@ -14,10 +14,10 @@ pub struct AndThen<A, B> {
impl<A, B> AndThen<A, B> {
/// Create new `AndThen` combinator
pub fn new<Request>(a: A, b: B) -> Self
pub fn new(a: A, b: B) -> Self
where
A: Service<Request>,
B: Service<A::Response, Error = A::Error>,
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
Self { a, b: Cell::new(b) }
}
@ -35,39 +35,40 @@ where
}
}
impl<A, B, Request> Service<Request> for AndThen<A, B>
impl<A, B> Service for AndThen<A, B>
where
A: Service<Request>,
B: Service<A::Response, Error = A::Error>,
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
type Request = A::Request;
type Response = B::Response;
type Error = A::Error;
type Future = AndThenFuture<A, B, Request>;
type Future = AndThenFuture<A, B>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
try_ready!(self.a.poll_ready());
self.b.get_mut().poll_ready()
}
fn call(&mut self, req: Request) -> Self::Future {
fn call(&mut self, req: A::Request) -> Self::Future {
AndThenFuture::new(self.a.call(req), self.b.clone())
}
}
pub struct AndThenFuture<A, B, Request>
pub struct AndThenFuture<A, B>
where
A: Service<Request>,
B: Service<A::Response, Error = A::Error>,
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
b: Cell<B>,
fut_b: Option<B::Future>,
fut_a: Option<A::Future>,
}
impl<A, B, Request> AndThenFuture<A, B, Request>
impl<A, B> AndThenFuture<A, B>
where
A: Service<Request>,
B: Service<A::Response, Error = A::Error>,
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
fn new(a: A::Future, b: Cell<B>) -> Self {
AndThenFuture {
@ -78,10 +79,10 @@ where
}
}
impl<A, B, Request> Future for AndThenFuture<A, B, Request>
impl<A, B> Future for AndThenFuture<A, B>
where
A: Service<Request>,
B: Service<A::Response, Error = A::Error>,
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
type Item = B::Response;
type Error = A::Error;
@ -111,10 +112,10 @@ pub struct AndThenNewService<A, B> {
impl<A, B> AndThenNewService<A, B> {
/// Create new `AndThen` combinator
pub fn new<Request, F: IntoNewService<B, A::Response>>(a: A, f: F) -> Self
pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self
where
A: NewService<Request>,
B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
{
Self {
a,
@ -123,17 +124,18 @@ impl<A, B> AndThenNewService<A, B> {
}
}
impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
impl<A, B> NewService for AndThenNewService<A, B>
where
A: NewService<Request>,
B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
{
type Request = A::Request;
type Response = B::Response;
type Error = A::Error;
type Service = AndThen<A::Service, B::Service>;
type InitError = A::InitError;
type Future = AndThenNewServiceFuture<A, B, Request>;
type Future = AndThenNewServiceFuture<A, B>;
fn new_service(&self) -> Self::Future {
AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@ -153,10 +155,10 @@ where
}
}
pub struct AndThenNewServiceFuture<A, B, Request>
pub struct AndThenNewServiceFuture<A, B>
where
A: NewService<Request>,
B: NewService<A::Response>,
A: NewService,
B: NewService<Request = A::Response>,
{
fut_b: B::Future,
fut_a: A::Future,
@ -164,10 +166,10 @@ where
b: Option<B::Service>,
}
impl<A, B, Request> AndThenNewServiceFuture<A, B, Request>
impl<A, B> AndThenNewServiceFuture<A, B>
where
A: NewService<Request>,
B: NewService<A::Response>,
A: NewService,
B: NewService<Request = A::Response>,
{
fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
AndThenNewServiceFuture {
@ -179,10 +181,10 @@ where
}
}
impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
impl<A, B> Future for AndThenNewServiceFuture<A, B>
where
A: NewService<Request>,
B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
{
type Item = AndThen<A::Service, B::Service>;
type Error = A::InitError;
@ -222,7 +224,8 @@ mod tests {
use crate::{NewService, Service, ServiceExt};
struct Srv1(Rc<Cell<usize>>);
impl Service<&'static str> for Srv1 {
impl Service for Srv1 {
type Request = &'static str;
type Response = &'static str;
type Error = ();
type Future = FutureResult<Self::Response, ()>;
@ -240,7 +243,8 @@ mod tests {
#[derive(Clone)]
struct Srv2(Rc<Cell<usize>>);
impl Service<&'static str> for Srv2 {
impl Service for Srv2 {
type Request = &'static str;
type Response = (&'static str, &'static str);
type Error = ();
type Future = FutureResult<Self::Response, ()>;

94
actix-service/src/and_then_apply.rs
View File

@ -6,10 +6,10 @@ use super::{IntoNewService, IntoService, NewService, Service};
use crate::cell::Cell;
/// `Apply` service combinator
pub struct AndThenApply<A, B, F, Out, Req1, Req2>
pub struct AndThenApply<A, B, F, Out>
where
A: Service<Req1>,
B: Service<Req2, Error = A::Error>,
A: Service,
B: Service<Error = A::Error>,
F: FnMut(A::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
@ -17,19 +17,19 @@ where
a: A,
b: Cell<B>,
f: Cell<F>,
r: PhantomData<(Out, Req1, Req2)>,
r: PhantomData<(Out,)>,
}
impl<A, B, F, Out, Req1, Req2> AndThenApply<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> AndThenApply<A, B, F, Out>
where
A: Service<Req1>,
B: Service<Req2, Error = A::Error>,
A: Service,
B: Service<Error = A::Error>,
F: FnMut(A::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
{
/// Create new `Apply` combinator
pub fn new<A1: IntoService<A, Req1>, B1: IntoService<B, Req2>>(a: A1, b: B1, f: F) -> Self {
pub fn new<A1: IntoService<A>, B1: IntoService<B>>(a: A1, b: B1, f: F) -> Self {
Self {
f: Cell::new(f),
a: a.into_service(),
@ -39,10 +39,10 @@ where
}
}
impl<A, B, F, Out, Req1, Req2> Clone for AndThenApply<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> Clone for AndThenApply<A, B, F, Out>
where
A: Service<Req1> + Clone,
B: Service<Req2, Error = A::Error>,
A: Service + Clone,
B: Service<Error = A::Error>,
F: FnMut(A::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
@ -57,38 +57,38 @@ where
}
}
impl<A, B, F, Out, Req1, Req2> Service<Req1> for AndThenApply<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> Service for AndThenApply<A, B, F, Out>
where
A: Service<Req1>,
B: Service<Req2, Error = A::Error>,
A: Service,
B: Service<Error = A::Error>,
F: FnMut(A::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
{
type Request = A::Request;
type Response = Out::Item;
type Error = A::Error;
type Future = AndThenApplyFuture<A, B, F, Out, Req1, Req2>;
type Future = AndThenApplyFuture<A, B, F, Out>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
try_ready!(self.a.poll_ready());
self.b.get_mut().poll_ready().map_err(|e| e.into())
}
fn call(&mut self, req: Req1) -> Self::Future {
fn call(&mut self, req: A::Request) -> Self::Future {
AndThenApplyFuture {
b: self.b.clone(),
f: self.f.clone(),
fut_b: None,
fut_a: Some(self.a.call(req)),
_t: PhantomData,
}
}
}
pub struct AndThenApplyFuture<A, B, F, Out, Req1, Req2>
pub struct AndThenApplyFuture<A, B, F, Out>
where
A: Service<Req1>,
B: Service<Req2, Error = A::Error>,
A: Service,
B: Service<Error = A::Error>,
F: FnMut(A::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
@ -97,13 +97,12 @@ where
f: Cell<F>,
fut_a: Option<A::Future>,
fut_b: Option<Out::Future>,
_t: PhantomData<Req2>,
}
impl<A, B, F, Out, Req1, Req2> Future for AndThenApplyFuture<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> Future for AndThenApplyFuture<A, B, F, Out>
where
A: Service<Req1>,
B: Service<Req2, Error = A::Error>,
A: Service,
B: Service<Error = A::Error>,
F: FnMut(A::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
@ -130,27 +129,23 @@ where
}
/// `ApplyNewService` new service combinator
pub struct AndThenApplyNewService<A, B, F, Out, Req1, Req2> {
pub struct AndThenApplyNewService<A, B, F, Out> {
a: A,
b: B,
f: Cell<F>,
r: PhantomData<(Out, Req1, Req2)>,
r: PhantomData<(Out)>,
}
impl<A, B, F, Out, Req1, Req2> AndThenApplyNewService<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> AndThenApplyNewService<A, B, F, Out>
where
A: NewService<Req1>,
B: NewService<Req2, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Error = A::Error, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
{
/// Create new `ApplyNewService` new service instance
pub fn new<A1: IntoNewService<A, Req1>, B1: IntoNewService<B, Req2>>(
a: A1,
b: B1,
f: F,
) -> Self {
pub fn new<A1: IntoNewService<A>, B1: IntoNewService<B>>(a: A1, b: B1, f: F) -> Self {
Self {
f: Cell::new(f),
a: a.into_new_service(),
@ -160,7 +155,7 @@ where
}
}
impl<A, B, F, Out, Req1, Req2> Clone for AndThenApplyNewService<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> Clone for AndThenApplyNewService<A, B, F, Out>
where
A: Clone,
B: Clone,
@ -175,21 +170,21 @@ where
}
}
impl<A, B, F, Out, Req1, Req2> NewService<Req1>
for AndThenApplyNewService<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> NewService for AndThenApplyNewService<A, B, F, Out>
where
A: NewService<Req1>,
B: NewService<Req2, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Error = A::Error, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
{
type Request = A::Request;
type Response = Out::Item;
type Error = A::Error;
type InitError = A::InitError;
type Service = AndThenApply<A::Service, B::Service, F, Out, Req1, Req2>;
type Future = AndThenApplyNewServiceFuture<A, B, F, Out, Req1, Req2>;
type Service = AndThenApply<A::Service, B::Service, F, Out>;
type Future = AndThenApplyNewServiceFuture<A, B, F, Out>;
fn new_service(&self) -> Self::Future {
AndThenApplyNewServiceFuture {
@ -202,10 +197,10 @@ where
}
}
pub struct AndThenApplyNewServiceFuture<A, B, F, Out, Req1, Req2>
pub struct AndThenApplyNewServiceFuture<A, B, F, Out>
where
A: NewService<Req1>,
B: NewService<Req2, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Error = A::Error, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
@ -217,15 +212,15 @@ where
b: Option<B::Service>,
}
impl<A, B, F, Out, Req1, Req2> Future for AndThenApplyNewServiceFuture<A, B, F, Out, Req1, Req2>
impl<A, B, F, Out> Future for AndThenApplyNewServiceFuture<A, B, F, Out>
where
A: NewService<Req1>,
B: NewService<Req2, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<Error = A::Error, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Out,
Out: IntoFuture,
Out::Error: Into<A::Error>,
{
type Item = AndThenApply<A::Service, B::Service, F, Out, Req1, Req2>;
type Item = AndThenApply<A::Service, B::Service, F, Out>;
type Error = A::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -263,7 +258,8 @@ mod tests {
#[derive(Clone)]
struct Srv;
impl Service<()> for Srv {
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;

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

@ -5,24 +5,24 @@ use futures::{Async, Future, IntoFuture, Poll};
use super::{IntoNewService, IntoService, NewService, Service};
/// `Apply` service combinator
pub struct Apply<T, F, In, Out, Request>
pub struct Apply<T, F, In, Out>
where
T: Service<Request>,
T: Service,
{
service: T,
f: F,
r: PhantomData<(In, Out, Request)>,
r: PhantomData<(In, Out)>,
}
impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
impl<T, F, In, Out> Apply<T, F, In, Out>
where
T: Service<Request>,
T: Service,
F: FnMut(In, &mut T) -> Out,
Out: IntoFuture,
Out::Error: From<T::Error>,
{
/// Create new `Apply` combinator
pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
pub fn new<I: IntoService<T>>(service: I, f: F) -> Self {
Self {
service: service.into_service(),
f,
@ -31,9 +31,9 @@ where
}
}
impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
where
T: Service<Request> + Clone,
T: Service + Clone,
F: Clone,
{
fn clone(&self) -> Self {
@ -45,13 +45,14 @@ where
}
}
impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
impl<T, F, In, Out> Service for Apply<T, F, In, Out>
where
T: Service<Request>,
T: Service,
F: FnMut(In, &mut T) -> Out,
Out: IntoFuture,
Out::Error: From<T::Error>,
{
type Request = In;
type Response = Out::Item;
type Error = Out::Error;
type Future = Out::Future;
@ -66,24 +67,24 @@ where
}
/// `ApplyNewService` new service combinator
pub struct ApplyNewService<T, F, In, Out, Request>
pub struct ApplyNewService<T, F, In, Out>
where
T: NewService<Request>,
T: NewService,
{
service: T,
f: F,
r: PhantomData<(In, Out, Request)>,
r: PhantomData<(In, Out)>,
}
impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
impl<T, F, In, Out> ApplyNewService<T, F, In, Out>
where
T: NewService<Request>,
T: NewService,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
{
/// Create new `ApplyNewService` new service instance
pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
pub fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
Self {
f,
service: service.into_new_service(),
@ -92,9 +93,9 @@ where
}
}
impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out>
where
T: NewService<Request> + Clone,
T: NewService + Clone,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
{
@ -107,28 +108,29 @@ where
}
}
impl<T, F, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
impl<T, F, In, Out> NewService for ApplyNewService<T, F, In, Out>
where
T: NewService<Request>,
T: NewService,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
{
type Request = In;
type Response = Out::Item;
type Error = Out::Error;
type Service = Apply<T::Service, F, In, Out, Request>;
type Service = Apply<T::Service, F, In, Out>;
type InitError = T::InitError;
type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
type Future = ApplyNewServiceFuture<T, F, In, Out>;
fn new_service(&self) -> Self::Future {
ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
}
}
pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
pub struct ApplyNewServiceFuture<T, F, In, Out>
where
T: NewService<Request>,
T: NewService,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
{
@ -137,9 +139,9 @@ where
r: PhantomData<(In, Out)>,
}
impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
impl<T, F, In, Out> ApplyNewServiceFuture<T, F, In, Out>
where
T: NewService<Request>,
T: NewService,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
{
@ -152,14 +154,14 @@ where
}
}
impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out>
where
T: NewService<Request>,
T: NewService,
F: FnMut(In, &mut T::Service) -> Out + Clone,
Out: IntoFuture,
Out::Error: From<T::Error>,
{
type Item = Apply<T::Service, F, In, Out, Request>;
type Item = Apply<T::Service, F, In, Out>;
type Error = T::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -180,7 +182,8 @@ mod tests {
#[derive(Clone)]
struct Srv;
impl Service<()> for Srv {
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;

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

@ -42,11 +42,12 @@ where
}
}
impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>
impl<F, Req, Resp, E, Fut> Service for FnService<F, Req, Resp, E, Fut>
where
F: FnMut(Req) -> Fut,
Fut: IntoFuture<Item = Resp, Error = E>,
{
type Request = Req;
type Response = Resp;
type Error = E;
type Future = Fut::Future;
@ -60,7 +61,7 @@ where
}
}
impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>, Req> for F
impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F
where
F: FnMut(Req) -> Fut + 'static,
Fut: IntoFuture<Item = Resp, Error = Err>,
@ -92,11 +93,12 @@ where
}
}
impl<F, Req, Resp, Err, Fut> NewService<Req> for FnNewService<F, Req, Resp, Err, Fut>
impl<F, Req, Resp, Err, Fut> NewService for FnNewService<F, Req, Resp, Err, Fut>
where
F: FnMut(Req) -> Fut + Clone,
Fut: IntoFuture<Item = Resp, Error = Err>,
{
type Request = Req;
type Response = Resp;
type Error = Err;
type Service = FnService<F, Req, Resp, Err, Fut>;
@ -108,7 +110,7 @@ where
}
}
impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>, Req> for F
impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>> for F
where
F: FnMut(Req) -> Fut + Clone + 'static,
Fut: IntoFuture<Item = Resp, Error = Err>,

41
actix-service/src/from_err.rs
View File

@ -13,9 +13,9 @@ pub struct FromErr<A, E> {
}
impl<A, E> FromErr<A, E> {
pub(crate) fn new<Request>(service: A) -> Self
pub(crate) fn new(service: A) -> Self
where
A: Service<Request>,
A: Service,
E: From<A::Error>,
{
FromErr {
@ -37,20 +37,21 @@ where
}
}
impl<A, E, Request> Service<Request> for FromErr<A, E>
impl<A, E> Service for FromErr<A, E>
where
A: Service<Request>,
A: Service,
E: From<A::Error>,
{
type Request = A::Request;
type Response = A::Response;
type Error = E;
type Future = FromErrFuture<A, E, Request>;
type Future = FromErrFuture<A, E>;
fn poll_ready(&mut self) -> Poll<(), E> {
self.service.poll_ready().map_err(E::from)
}
fn call(&mut self, req: Request) -> Self::Future {
fn call(&mut self, req: A::Request) -> Self::Future {
FromErrFuture {
fut: self.service.call(req),
f: PhantomData,
@ -58,14 +59,14 @@ where
}
}
pub struct FromErrFuture<A: Service<Request>, E, Request> {
pub struct FromErrFuture<A: Service, E> {
fut: A::Future,
f: PhantomData<E>,
}
impl<A, E, Request> Future for FromErrFuture<A, E, Request>
impl<A, E> Future for FromErrFuture<A, E>
where
A: Service<Request>,
A: Service,
E: From<A::Error>,
{
type Item = A::Response;
@ -87,9 +88,9 @@ pub struct FromErrNewService<A, E> {
impl<A, E> FromErrNewService<A, E> {
/// Create new `FromErr` new service instance
pub fn new<Request>(a: A) -> Self
pub fn new(a: A) -> Self
where
A: NewService<Request>,
A: NewService,
E: From<A::Error>,
{
Self { a, e: PhantomData }
@ -108,17 +109,18 @@ where
}
}
impl<A, E, Request> NewService<Request> for FromErrNewService<A, E>
impl<A, E> NewService for FromErrNewService<A, E>
where
A: NewService<Request>,
A: NewService,
E: From<A::Error>,
{
type Request = A::Request;
type Response = A::Response;
type Error = E;
type Service = FromErr<A::Service, E>;
type InitError = A::InitError;
type Future = FromErrNewServiceFuture<A, E, Request>;
type Future = FromErrNewServiceFuture<A, E>;
fn new_service(&self) -> Self::Future {
FromErrNewServiceFuture {
@ -128,18 +130,18 @@ where
}
}
pub struct FromErrNewServiceFuture<A, E, Request>
pub struct FromErrNewServiceFuture<A, E>
where
A: NewService<Request>,
A: NewService,
E: From<A::Error>,
{
fut: A::Future,
e: PhantomData<E>,
}
impl<A, E, Request> Future for FromErrNewServiceFuture<A, E, Request>
impl<A, E> Future for FromErrNewServiceFuture<A, E>
where
A: NewService<Request>,
A: NewService,
E: From<A::Error>,
{
type Item = FromErr<A::Service, E>;
@ -162,7 +164,8 @@ mod tests {
use crate::{IntoNewService, NewService, Service, ServiceExt};
struct Srv;
impl Service<()> for Srv {
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;

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

@ -22,7 +22,10 @@ pub use self::map_init_err::MapInitErr;
pub use self::then::{Then, ThenNewService};
/// An asynchronous function from `Request` to a `Response`.
pub trait Service<Request> {
pub trait Service {
/// Requests handled by the service.
type Request;
/// Responses given by the service.
type Response;
@ -52,23 +55,19 @@ pub trait Service<Request> {
///
/// Calling `call` without calling `poll_ready` is permitted. The
/// implementation must be resilient to this fact.
fn call(&mut self, req: Request) -> Self::Future;
fn call(&mut self, req: Self::Request) -> Self::Future;
}
/// An extension trait for `Service`s that provides a variety of convenient
/// adapters
pub trait ServiceExt<Request>: Service<Request> {
pub trait ServiceExt: Service {
/// Apply function to specified service and use it as a next service in
/// chain.
fn apply<B, I, F, Out, Req>(
self,
service: I,
f: F,
) -> AndThenApply<Self, B, F, Out, Request, Req>
fn apply<B, I, F, Out, Req>(self, service: I, f: F) -> AndThenApply<Self, B, F, Out>
where
Self: Sized,
B: Service<Req, Error = Self::Error>,
I: IntoService<B, Req>,
B: Service<Request = Req, Error = Self::Error>,
I: IntoService<B>,
F: FnMut(Self::Response, &mut B) -> Out,
Out: IntoFuture,
Out::Error: Into<Self::Error>,
@ -88,8 +87,8 @@ pub trait ServiceExt<Request>: Service<Request> {
fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
where
Self: Sized,
F: IntoService<B, Self::Response>,
B: Service<Self::Response, Error = Self::Error>,
F: IntoService<B>,
B: Service<Request = Self::Response, Error = Self::Error>,
{
AndThen::new(self, service.into_service())
}
@ -115,7 +114,7 @@ pub trait ServiceExt<Request>: Service<Request> {
fn then<B>(self, service: B) -> Then<Self, B>
where
Self: Sized,
B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
{
Then::new(self, service)
}
@ -154,7 +153,7 @@ pub trait ServiceExt<Request>: Service<Request> {
}
}
impl<T: ?Sized, Request> ServiceExt<Request> for T where T: Service<Request> {}
impl<T: ?Sized> ServiceExt for T where T: Service {}
/// Creates new `Service` values.
///
@ -163,9 +162,10 @@ impl<T: ?Sized, Request> ServiceExt<Request> for T where T: Service<Request> {}
/// accepts new TCP streams, obtains a new `Service` value using the
/// `NewService` trait, and uses that new `Service` value to process inbound
/// requests on that new TCP stream.
///
/// Request - request handled by the service
pub trait NewService<Request> {
pub trait NewService {
/// Requests handled by the service.
type Request;
/// Responses given by the service
type Response;
@ -173,7 +173,11 @@ pub trait NewService<Request> {
type Error;
/// The `Service` value created by this factory
type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
type Service: Service<
Request = Self::Request,
Response = Self::Response,
Error = Self::Error,
>;
/// Errors produced while building a service.
type InitError;
@ -190,11 +194,11 @@ pub trait NewService<Request> {
self,
service: I,
f: F,
) -> AndThenApplyNewService<Self, B, F, Out, Request, Req>
) -> AndThenApplyNewService<Self, B, F, Out>
where
Self: Sized,
B: NewService<Req, Error = Self::Error, InitError = Self::InitError>,
I: IntoNewService<B, Req>,
B: NewService<Request = Req, Error = Self::Error, InitError = Self::InitError>,
I: IntoNewService<B>,
F: FnMut(Self::Response, &mut B::Service) -> Out,
Out: IntoFuture,
Out::Error: Into<Self::Error>,
@ -206,8 +210,12 @@ pub trait NewService<Request> {
fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
where
Self: Sized,
F: IntoNewService<B, Self::Response>,
B: NewService<Self::Response, Error = Self::Error, InitError = Self::InitError>,
F: IntoNewService<B>,
B: NewService<
Request = Self::Response,
Error = Self::Error,
InitError = Self::InitError,
>,
{
AndThenNewService::new(self, new_service)
}
@ -235,9 +243,9 @@ pub trait NewService<Request> {
fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
where
Self: Sized,
F: IntoNewService<B, Result<Self::Response, Self::Error>>,
F: IntoNewService<B>,
B: NewService<
Result<Self::Response, Self::Error>,
Request = Result<Self::Response, Self::Error>,
Error = Self::Error,
InitError = Self::InitError,
>,
@ -274,10 +282,11 @@ pub trait NewService<Request> {
}
}
impl<'a, S, Request> Service<Request> for &'a mut S
impl<'a, S> Service for &'a mut S
where
S: Service<Request> + 'a,
S: Service + 'a,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
@ -286,15 +295,16 @@ where
(**self).poll_ready()
}
fn call(&mut self, request: Request) -> S::Future {
fn call(&mut self, request: Self::Request) -> S::Future {
(**self).call(request)
}
}
impl<S, Request> Service<Request> for Box<S>
impl<S> Service for Box<S>
where
S: Service<Request> + ?Sized,
S: Service + ?Sized,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
@ -303,17 +313,18 @@ where
(**self).poll_ready()
}
fn call(&mut self, request: Request) -> S::Future {
fn call(&mut self, request: Self::Request) -> S::Future {
(**self).call(request)
}
}
impl<F, R, E, S, Request> NewService<Request> for F
impl<F, R, E, S> NewService for F
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
S: Service<Request>,
S: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Service = S;
@ -326,35 +337,35 @@ where
}
/// Trait for types that can be converted to a `Service`
pub trait IntoService<T, Request>
pub trait IntoService<T>
where
T: Service<Request>,
T: Service,
{
/// Convert to a `Service`
fn into_service(self) -> T;
}
/// Trait for types that can be converted to a Service
pub trait IntoNewService<T, Request>
pub trait IntoNewService<T>
where
T: NewService<Request>,
T: NewService,
{
/// Convert to an `NewService`
fn into_new_service(self) -> T;
}
impl<T, Request> IntoService<T, Request> for T
impl<T> IntoService<T> for T
where
T: Service<Request>,
T: Service,
{
fn into_service(self) -> T {
self
}
}
impl<T, Request> IntoNewService<T, Request> for T
impl<T> IntoNewService<T> for T
where
T: NewService<Request>,
T: NewService,
{
fn into_new_service(self) -> T {
self

51
actix-service/src/map.rs
View File

@ -15,9 +15,9 @@ pub struct Map<A, F, Response> {
impl<A, F, Response> Map<A, F, Response> {
/// Create new `Map` combinator
pub fn new<Request>(service: A, f: F) -> Self
pub fn new(service: A, f: F) -> Self
where
A: Service<Request>,
A: Service,
F: FnMut(A::Response) -> Response,
{
Self {
@ -42,36 +42,37 @@ where
}
}
impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>
impl<A, F, Response> Service for Map<A, F, Response>
where
A: Service<Request>,
A: Service,
F: FnMut(A::Response) -> Response + Clone,
{
type Request = A::Request;
type Response = Response;
type Error = A::Error;
type Future = MapFuture<A, F, Request, Response>;
type Future = MapFuture<A, F, Response>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.poll_ready()
}
fn call(&mut self, req: Request) -> Self::Future {
fn call(&mut self, req: A::Request) -> Self::Future {
MapFuture::new(self.service.call(req), self.f.clone())
}
}
pub struct MapFuture<A, F, Request, Response>
pub struct MapFuture<A, F, Response>
where
A: Service<Request>,
A: Service,
F: FnMut(A::Response) -> Response,
{
f: F,
fut: A::Future,
}
impl<A, F, Request, Response> MapFuture<A, F, Request, Response>
impl<A, F, Response> MapFuture<A, F, Response>
where
A: Service<Request>,
A: Service,
F: FnMut(A::Response) -> Response,
{
fn new(fut: A::Future, f: F) -> Self {
@ -79,9 +80,9 @@ where
}
}
impl<A, F, Request, Response> Future for MapFuture<A, F, Request, Response>
impl<A, F, Response> Future for MapFuture<A, F, Response>
where
A: Service<Request>,
A: Service,
F: FnMut(A::Response) -> Response,
{
type Item = Response;
@ -104,9 +105,9 @@ pub struct MapNewService<A, F, Response> {
impl<A, F, Response> MapNewService<A, F, Response> {
/// Create new `Map` new service instance
pub fn new<Request>(a: A, f: F) -> Self
pub fn new(a: A, f: F) -> Self
where
A: NewService<Request>,
A: NewService,
F: FnMut(A::Response) -> Response,
{
Self {
@ -131,35 +132,36 @@ where
}
}
impl<A, F, Request, Response> NewService<Request> for MapNewService<A, F, Response>
impl<A, F, Response> NewService for MapNewService<A, F, Response>
where
A: NewService<Request>,
A: NewService,
F: FnMut(A::Response) -> Response + Clone,
{
type Request = A::Request;
type Response = Response;
type Error = A::Error;
type Service = Map<A::Service, F, Response>;
type InitError = A::InitError;
type Future = MapNewServiceFuture<A, F, Request, Response>;
type Future = MapNewServiceFuture<A, F, Response>;
fn new_service(&self) -> Self::Future {
MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
}
}
pub struct MapNewServiceFuture<A, F, Request, Response>
pub struct MapNewServiceFuture<A, F, Response>
where
A: NewService<Request>,
A: NewService,
F: FnMut(A::Response) -> Response,
{
fut: A::Future,
f: Option<F>,
}
impl<A, F, Request, Response> MapNewServiceFuture<A, F, Request, Response>
impl<A, F, Response> MapNewServiceFuture<A, F, Response>
where
A: NewService<Request>,
A: NewService,
F: FnMut(A::Response) -> Response,
{
fn new(fut: A::Future, f: F) -> Self {
@ -167,9 +169,9 @@ where
}
}
impl<A, F, Request, Response> Future for MapNewServiceFuture<A, F, Request, Response>
impl<A, F, Response> Future for MapNewServiceFuture<A, F, Response>
where
A: NewService<Request>,
A: NewService,
F: FnMut(A::Response) -> Response,
{
type Item = Map<A::Service, F, Response>;
@ -192,7 +194,8 @@ mod tests {
use crate::{IntoNewService, Service, ServiceExt};
struct Srv;
impl Service<()> for Srv {
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;

51
actix-service/src/map_err.rs
View File

@ -16,9 +16,9 @@ pub struct MapErr<A, F, E> {
impl<A, F, E> MapErr<A, F, E> {
/// Create new `MapErr` combinator
pub fn new<Request>(service: A, f: F) -> Self
pub fn new(service: A, f: F) -> Self
where
A: Service<Request>,
A: Service,
F: Fn(A::Error) -> E,
{
Self {
@ -43,36 +43,37 @@ where
}
}
impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>
impl<A, F, E> Service for MapErr<A, F, E>
where
A: Service<Request>,
A: Service,
F: Fn(A::Error) -> E + Clone,
{
type Request = A::Request;
type Response = A::Response;
type Error = E;
type Future = MapErrFuture<A, F, E, Request>;
type Future = MapErrFuture<A, F, E>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.poll_ready().map_err(&self.f)
}
fn call(&mut self, req: Request) -> Self::Future {
fn call(&mut self, req: A::Request) -> Self::Future {
MapErrFuture::new(self.service.call(req), self.f.clone())
}
}
pub struct MapErrFuture<A, F, E, Request>
pub struct MapErrFuture<A, F, E>
where
A: Service<Request>,
A: Service,
F: Fn(A::Error) -> E,
{
f: F,
fut: A::Future,
}
impl<A, F, E, Request> MapErrFuture<A, F, E, Request>
impl<A, F, E> MapErrFuture<A, F, E>
where
A: Service<Request>,
A: Service,
F: Fn(A::Error) -> E,
{
fn new(fut: A::Future, f: F) -> Self {
@ -80,9 +81,9 @@ where
}
}
impl<A, F, E, Request> Future for MapErrFuture<A, F, E, Request>
impl<A, F, E> Future for MapErrFuture<A, F, E>
where
A: Service<Request>,
A: Service,
F: Fn(A::Error) -> E,
{
type Item = A::Response;
@ -105,9 +106,9 @@ pub struct MapErrNewService<A, F, E> {
impl<A, F, E> MapErrNewService<A, F, E> {
/// Create new `MapErr` new service instance
pub fn new<Request>(a: A, f: F) -> Self
pub fn new(a: A, f: F) -> Self
where
A: NewService<Request>,
A: NewService,
F: Fn(A::Error) -> E,
{
Self {
@ -132,35 +133,36 @@ where
}
}
impl<A, F, E, Request> NewService<Request> for MapErrNewService<A, F, E>
impl<A, F, E> NewService for MapErrNewService<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::Error) -> E + Clone,
{
type Request = A::Request;
type Response = A::Response;
type Error = E;
type Service = MapErr<A::Service, F, E>;
type InitError = A::InitError;
type Future = MapErrNewServiceFuture<A, F, E, Request>;
type Future = MapErrNewServiceFuture<A, F, E>;
fn new_service(&self) -> Self::Future {
MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
}
}
pub struct MapErrNewServiceFuture<A, F, E, Request>
pub struct MapErrNewServiceFuture<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::Error) -> E,
{
fut: A::Future,
f: F,
}
impl<A, F, E, Request> MapErrNewServiceFuture<A, F, E, Request>
impl<A, F, E> MapErrNewServiceFuture<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::Error) -> E,
{
fn new(fut: A::Future, f: F) -> Self {
@ -168,9 +170,9 @@ where
}
}
impl<A, F, E, Request> Future for MapErrNewServiceFuture<A, F, E, Request>
impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::Error) -> E + Clone,
{
type Item = MapErr<A::Service, F, E>;
@ -194,7 +196,8 @@ mod tests {
struct Srv;
impl Service<()> for Srv {
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;

23
actix-service/src/map_init_err.rs
View File

@ -13,9 +13,9 @@ pub struct MapInitErr<A, F, E> {
impl<A, F, E> MapInitErr<A, F, E> {
/// Create new `MapInitErr` combinator
pub fn new<Request>(a: A, f: F) -> Self
pub fn new(a: A, f: F) -> Self
where
A: NewService<Request>,
A: NewService,
F: Fn(A::InitError) -> E,
{
Self {
@ -40,35 +40,36 @@ where
}
}
impl<A, F, E, Request> NewService<Request> for MapInitErr<A, F, E>
impl<A, F, E> NewService for MapInitErr<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::InitError) -> E + Clone,
{
type Request = A::Request;
type Response = A::Response;
type Error = A::Error;
type Service = A::Service;
type InitError = E;
type Future = MapInitErrFuture<A, F, E, Request>;
type Future = MapInitErrFuture<A, F, E>;
fn new_service(&self) -> Self::Future {
MapInitErrFuture::new(self.a.new_service(), self.f.clone())
}
}
pub struct MapInitErrFuture<A, F, E, Request>
pub struct MapInitErrFuture<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::InitError) -> E,
{
f: F,
fut: A::Future,
}
impl<A, F, E, Request> MapInitErrFuture<A, F, E, Request>
impl<A, F, E> MapInitErrFuture<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::InitError) -> E,
{
fn new(fut: A::Future, f: F) -> Self {
@ -76,9 +77,9 @@ where
}
}
impl<A, F, E, Request> Future for MapInitErrFuture<A, F, E, Request>
impl<A, F, E> Future for MapInitErrFuture<A, F, E>
where
A: NewService<Request>,
A: NewService,
F: Fn(A::InitError) -> E,
{
type Item = A::Service;

92
actix-service/src/then.rs
View File

@ -14,10 +14,10 @@ pub struct Then<A, B> {
impl<A, B> Then<A, B> {
/// Create new `Then` combinator
pub fn new<Request>(a: A, b: B) -> Then<A, B>
pub fn new(a: A, b: B) -> Then<A, B>
where
A: Service<Request>,
B: Service<Result<A::Response, A::Error>, Error = A::Error>,
A: Service,
B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
{
Then { a, b: Cell::new(b) }
}
@ -35,39 +35,40 @@ where
}
}
impl<A, B, Request> Service<Request> for Then<A, B>
impl<A, B> Service for Then<A, B>
where
A: Service<Request>,
B: Service<Result<A::Response, A::Error>, Error = A::Error>,
A: Service,
B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
{
type Request = A::Request;
type Response = B::Response;
type Error = B::Error;
type Future = ThenFuture<A, B, Request>;
type Future = ThenFuture<A, B>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
try_ready!(self.a.poll_ready());
self.b.get_mut().poll_ready()
}
fn call(&mut self, req: Request) -> Self::Future {
fn call(&mut self, req: A::Request) -> Self::Future {
ThenFuture::new(self.a.call(req), self.b.clone())
}
}
pub struct ThenFuture<A, B, Request>
pub struct ThenFuture<A, B>
where
A: Service<Request>,
B: Service<Result<A::Response, A::Error>>,
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
b: Cell<B>,
fut_b: Option<B::Future>,
fut_a: Option<A::Future>,
}
impl<A, B, Request> ThenFuture<A, B, Request>
impl<A, B> ThenFuture<A, B>
where
A: Service<Request>,
B: Service<Result<A::Response, A::Error>>,
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
fn new(a: A::Future, b: Cell<B>) -> Self {
ThenFuture {
@ -78,10 +79,10 @@ where
}
}
impl<A, B, Request> Future for ThenFuture<A, B, Request>
impl<A, B> Future for ThenFuture<A, B>
where
A: Service<Request>,
B: Service<Result<A::Response, A::Error>>,
A: Service,
B: Service<Request = Result<A::Response, A::Error>>,
{
type Item = B::Response;
type Error = B::Error;
@ -115,15 +116,15 @@ pub struct ThenNewService<A, B> {
impl<A, B> ThenNewService<A, B> {
/// Create new `AndThen` combinator
pub fn new<F, Request>(a: A, f: F) -> Self
pub fn new<F>(a: A, f: F) -> Self
where
A: NewService<Request>,
A: NewService,
B: NewService<
Result<A::Response, A::Error>,
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
F: IntoNewService<B, Result<A::Response, A::Error>>,
F: IntoNewService<B>,
{
Self {
a,
@ -132,17 +133,22 @@ impl<A, B> ThenNewService<A, B> {
}
}
impl<A, B, Request> NewService<Request> for ThenNewService<A, B>
impl<A, B> NewService for ThenNewService<A, B>
where
A: NewService<Request>,
B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{
type Request = A::Request;
type Response = B::Response;
type Error = A::Error;
type Service = Then<A::Service, B::Service>;
type InitError = A::InitError;
type Future = ThenNewServiceFuture<A, B, Request>;
type Future = ThenNewServiceFuture<A, B>;
fn new_service(&self) -> Self::Future {
ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@ -162,10 +168,14 @@ where
}
}
pub struct ThenNewServiceFuture<A, B, Request>
pub struct ThenNewServiceFuture<A, B>
where
A: NewService<Request>,
B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{
fut_b: B::Future,
fut_a: A::Future,
@ -173,10 +183,14 @@ where
b: Option<B::Service>,
}
impl<A, B, Request> ThenNewServiceFuture<A, B, Request>
impl<A, B> ThenNewServiceFuture<A, B>
where
A: NewService<Request>,
B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{
fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
ThenNewServiceFuture {
@ -188,10 +202,14 @@ where
}
}
impl<A, B, Request> Future for ThenNewServiceFuture<A, B, Request>
impl<A, B> Future for ThenNewServiceFuture<A, B>
where
A: NewService<Request>,
B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
A: NewService,
B: NewService<
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{
type Item = Then<A::Service, B::Service>;
type Error = A::InitError;
@ -231,7 +249,8 @@ mod tests {
#[derive(Clone)]
struct Srv1(Rc<Cell<usize>>);
impl Service<Result<&'static str, &'static str>> for Srv1 {
impl Service for Srv1 {
type Request = Result<&'static str, &'static str>;
type Response = &'static str;
type Error = ();
type Future = FutureResult<Self::Response, Self::Error>;
@ -251,7 +270,8 @@ mod tests {
struct Srv2(Rc<Cell<usize>>);
impl Service<Result<&'static str, ()>> for Srv2 {
impl Service for Srv2 {
type Request = Result<&'static str, ()>;
type Response = (&'static str, &'static str);
type Error = ();
type Future = FutureResult<Self::Response, ()>;