Struct shuttle_next::http::Request

pub struct Request<T> { /* private fields */ }

Represents an HTTP request.

An HTTP request consists of a head and a potentially optional body. The body component is generic, enabling arbitrary types to represent the HTTP body. For example, the body could be Vec<u8>, a Stream of byte chunks, or a value that has been deserialized.

Examples

Creating a Request to send

use http::{Request, Response};

let mut request = Request::builder()
    .uri("https://www.rust-lang.org/")
    .header("User-Agent", "my-awesome-agent/1.0");

if needs_awesome_header() {
    request = request.header("Awesome", "yes");
}

let response = send(request.body(()).unwrap());

fn send(req: Request<()>) -> Response<()> {
    // ...
}

Inspecting a request to see what was sent.

use http::{Request, Response, StatusCode};

fn respond_to(req: Request<()>) -> http::Result<Response<()>> {
    if req.uri() != "/awesome-url" {
        return Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body(())
    }

    let has_awesome_header = req.headers().contains_key("Awesome");
    let body = req.body();

    // ...
}

Deserialize a request of bytes via json:

use http::Request;
use serde::de;

fn deserialize<T>(req: Request<Vec<u8>>) -> serde_json::Result<Request<T>>
    where for<'de> T: de::Deserialize<'de>,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::from_slice(&body)?;
    Ok(Request::from_parts(parts, body))
}

Or alternatively, serialize the body of a request to json

use http::Request;
use serde::ser;

fn serialize<T>(req: Request<T>) -> serde_json::Result<Request<Vec<u8>>>
    where T: ser::Serialize,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::to_vec(&body)?;
    Ok(Request::from_parts(parts, body))
}

Implementations

impl Request<()>

pub fn builder() -> Builder

Creates a new builder-style object to manufacture a Request

This method returns an instance of Builder which can be used to create a Request.

Examples

let request = Request::builder()
    .method("GET")
    .uri("https://www.rust-lang.org/")
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

pub fn get<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a GET method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::get("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn put<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a PUT method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::put("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn post<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a POST method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::post("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn delete<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a DELETE method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::delete("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn options<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with an OPTIONS method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::options("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn head<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a HEAD method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::head("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn connect<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a CONNECT method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::connect("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn patch<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a PATCH method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::patch("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn trace<T>(uri: T) -> Builder

where Uri: TryFrom<T>, <Uri as TryFrom<T>>::Error: Into<Error>,

Creates a new Builder initialized with a TRACE method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::trace("https://www.rust-lang.org/")
    .body(())
    .unwrap();

impl<T> Request<T>

pub fn new(body: T) -> Request<T>

Creates a new blank Request with the body

The component parts of this request will be set to their default, e.g. the GET method, no headers, etc.

Examples

let request = Request::new("hello world");

assert_eq!(*request.method(), Method::GET);
assert_eq!(*request.body(), "hello world");

pub fn from_parts(parts: Parts, body: T) -> Request<T>

Creates a new Request with the given components parts and body.

Examples

let request = Request::new("hello world");
let (mut parts, body) = request.into_parts();
parts.method = Method::POST;

let request = Request::from_parts(parts, body);

pub fn method(&self) -> &Method

Returns a reference to the associated HTTP method.

Examples

let request: Request<()> = Request::default();
assert_eq!(*request.method(), Method::GET);

pub fn method_mut(&mut self) -> &mut Method

Returns a mutable reference to the associated HTTP method.

Examples

let mut request: Request<()> = Request::default();
*request.method_mut() = Method::PUT;
assert_eq!(*request.method(), Method::PUT);

pub fn uri(&self) -> &Uri

Returns a reference to the associated URI.

Examples

let request: Request<()> = Request::default();
assert_eq!(*request.uri(), *"/");

pub fn uri_mut(&mut self) -> &mut Uri

Returns a mutable reference to the associated URI.

Examples

let mut request: Request<()> = Request::default();
*request.uri_mut() = "/hello".parse().unwrap();
assert_eq!(*request.uri(), *"/hello");

pub fn version(&self) -> Version

Returns the associated version.

Examples

let request: Request<()> = Request::default();
assert_eq!(request.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut request: Request<()> = Request::default();
*request.version_mut() = Version::HTTP_2;
assert_eq!(request.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

Examples

let request: Request<()> = Request::default();
assert!(request.headers().is_empty());

pub fn headers_mut(&mut self) -> &mut HeaderMap

Returns a mutable reference to the associated header field map.

Examples

let mut request: Request<()> = Request::default();
request.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!request.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

Examples

let request: Request<()> = Request::default();
assert!(request.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Examples

let mut request: Request<()> = Request::default();
request.extensions_mut().insert("hello");
assert_eq!(request.extensions().get(), Some(&"hello"));

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

Examples

let request: Request<String> = Request::default();
assert!(request.body().is_empty());

pub fn body_mut(&mut self) -> &mut T

Returns a mutable reference to the associated HTTP body.

Examples

let mut request: Request<String> = Request::default();
request.body_mut().push_str("hello world");
assert!(!request.body().is_empty());

pub fn into_body(self) -> T

Consumes the request, returning just the body.

Examples

let request = Request::new(10);
let body = request.into_body();
assert_eq!(body, 10);

pub fn into_parts(self) -> (Parts, T)

Consumes the request returning the head and body parts.

Examples

let request = Request::new(());
let (parts, body) = request.into_parts();
assert_eq!(parts.method, Method::GET);

pub fn map<F, U>(self, f: F) -> Request<U>

where F: FnOnce(T) -> U,

Consumes the request returning a new request with body mapped to the return type of the passed in function.

Examples

let request = Request::builder().body("some string").unwrap();
let mapped_request: Request<&[u8]> = request.map(|b| {
  assert_eq!(b, "some string");
  b.as_bytes()
});
assert_eq!(mapped_request.body(), &"some string".as_bytes());

Trait Implementations

impl<T> Debug for Request<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for Request<T>

where T: Default,

fn default() -> Request<T>

Returns the “default value” for a type.

impl<S, B> FromRequest<S, B> for Request<B>

where B: Send, S: Send + Sync,

type Rejection = Infallible

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request<'life0, 'async_trait>( req: Request<B>, _: &'life0 S ) -> Pin<Box<dyn Future<Output = Result<Request<B>, <Request<B> as FromRequest<S, B>>::Rejection>> + Send + 'async_trait>>

where 'life0: 'async_trait, Request<B>: 'async_trait,

Perform the extraction.

impl<B> Body for Request<B>

where B: Body,

type Data = <B as Body>::Data

Values yielded by the Body.

type Error = <B as Body>::Error

The error type this Body might generate.

fn poll_data( self: Pin<&mut Request<B>>, cx: &mut Context<'_> ) -> Poll<Option<Result<<Request<B> as Body>::Data, <Request<B> as Body>::Error>>>

Attempt to pull out the next data buffer of this stream.

fn poll_trailers( self: Pin<&mut Request<B>>, cx: &mut Context<'_> ) -> Poll<Result<Option<HeaderMap>, <Request<B> as Body>::Error>>

Poll for an optional single HeaderMap of trailers.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.

fn map_data<F, B>(self, f: F) -> MapData<Self, F>

where Self: Sized, F: FnMut(Self::Data) -> B, B: Buf,

Maps this body’s data value to a different value.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F>

where Self: Sized, F: FnMut(Self::Error) -> E,

Maps this body’s error value to a different value.

fn collect(self) -> Collect<Self>

where Self: Sized,

Turn this body into Collected body which will collect all the DATA frames and trailers.

impl<B> IntoMapRequestResult<B> for Request<B>

fn into_map_request_result( self ) -> Result<Request<B>, Response<UnsyncBoxBody<Bytes, Error>>>

Perform the conversion.

impl<B> RequestExt<B> for Request<B>

where B: Send + 'static,

fn extract<E, M>( self ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequest<(), B, M>>::Rejection>> + Send>>

where E: FromRequest<(), B, M> + 'static, M: 'static,

Apply an extractor to this Request.

fn extract_with_state<E, S, M>( self, state: &S ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequest<S, B, M>>::Rejection>> + Send + '_>>

where E: FromRequest<S, B, M> + 'static, S: Send + Sync,

Apply an extractor that requires some state to this Request.

fn extract_parts<E>( &mut self ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequestParts<()>>::Rejection>> + Send + '_>>

where E: FromRequestParts<()> + 'static,

Apply a parts extractor to this Request.

fn extract_parts_with_state<'a, E, S>( &'a mut self, state: &'a S ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequestParts<S>>::Rejection>> + Send + 'a>>

where E: FromRequestParts<S> + 'static, S: Send + Sync,

Apply a parts extractor that requires some state to this Request.

fn with_limited_body(self) -> Result<Request<Limited<B>>, Request<B>>

Apply the default body limit.

fn into_limited_body(self) -> Result<Limited<B>, B>

Consumes the request, returning the body wrapped in Limited if a default limit is in place, or not wrapped if the default limit is disabled.

impl<T, E, B, S> Service<Request<B>> for FromExtractor<T, E, S>

where E: FromRequestParts<S> + 'static, B: Send + 'static, T: Service<Request<B>> + Clone, <T as Service<Request<B>>>::Response: IntoResponse, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = <T as Service<Request<B>>>::Error

Errors produced by the service.

type Future = ResponseFuture<B, T, E, S>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromExtractor<T, E, S> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromExtractor<T, E, S> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1> Service<Request<B>> for FromFn<F, S, I, (T1,)>

where F: FnMut(T1, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1,)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1,)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2> Service<Request<B>> for FromFn<F, S, I, (T1, T2)>

where F: FnMut(T1, T2, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3)>

where F: FnMut(T1, T2, T3, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4)>

where F: FnMut(T1, T2, T3, T4, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5)>

where F: FnMut(T1, T2, T3, T4, T5, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)>

where F: FnMut(T1, T2, T3, T4, T5, T6, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, Out, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Service<Request<B>> for FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, Next<B>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequestParts<S> + Send, T16: FromRequest<S, B> + Send, Fut: Future<Output = Out> + Send + 'static, Out: IntoResponse + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Fut, Res> Service<Request<B>> for HandleError<S, F, ()>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(<S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, ()> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, ()> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1> Service<Request<B>> for HandleError<S, F, (T1,)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1,)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1,)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2> Service<Request<B>> for HandleError<S, F, (T1, T2)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3> Service<Request<B>> for HandleError<S, F, (T1, T2, T3)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, T11: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, T11: FromRequestParts<()> + Send, T12: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, T11: FromRequestParts<()> + Send, T12: FromRequestParts<()> + Send, T13: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, T11: FromRequestParts<()> + Send, T12: FromRequestParts<()> + Send, T13: FromRequestParts<()> + Send, T14: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, T11: FromRequestParts<()> + Send, T12: FromRequestParts<()> + Send, T13: FromRequestParts<()> + Send, T14: FromRequestParts<()> + Send, T15: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<S, F, B, Res, Fut, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Service<Request<B>> for HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>

where S: Service<Request<B>> + Clone + Send + 'static, <S as Service<Request<B>>>::Response: IntoResponse + Send, <S as Service<Request<B>>>::Error: Send, <S as Service<Request<B>>>::Future: Send, F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, <S as Service<Request<B>>>::Error) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, T1: FromRequestParts<()> + Send, T2: FromRequestParts<()> + Send, T3: FromRequestParts<()> + Send, T4: FromRequestParts<()> + Send, T5: FromRequestParts<()> + Send, T6: FromRequestParts<()> + Send, T7: FromRequestParts<()> + Send, T8: FromRequestParts<()> + Send, T9: FromRequestParts<()> + Send, T10: FromRequestParts<()> + Send, T11: FromRequestParts<()> + Send, T12: FromRequestParts<()> + Send, T13: FromRequestParts<()> + Send, T14: FromRequestParts<()> + Send, T15: FromRequestParts<()> + Send, T16: FromRequestParts<()> + Send, B: Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = HandleErrorFuture

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<H, T, S, B> Service<Request<B>> for HandlerService<H, T, S, B>

where H: Handler<T, S, B> + Clone + Send + 'static, B: Send + 'static, S: Clone + Send + Sync,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = IntoServiceFuture<<H as Handler<T, S, B>>::Future>

The future response value.

fn poll_ready( &mut self, _cx: &mut Context<'_> ) -> Poll<Result<(), <HandlerService<H, T, S, B> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <HandlerService<H, T, S, B> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1> Service<Request<B>> for MapRequest<F, S, I, (T1,)>

where F: FnMut(T1) -> Fut + Clone + Send + 'static, T1: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1,)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1,)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2> Service<Request<B>> for MapRequest<F, S, I, (T1, T2)>

where F: FnMut(T1, T2) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3)>

where F: FnMut(T1, T2, T3) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4)>

where F: FnMut(T1, T2, T3, T4) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5)>

where F: FnMut(T1, T2, T3, T4, T5) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6)>

where F: FnMut(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Service<Request<B>> for MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequestParts<S> + Send, T16: FromRequest<S, B> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoMapRequestResult<B> + Send + 'static, I: Service<Request<B>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Response: IntoResponse, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody> Service<Request<B>> for MapResponse<F, S, I, ()>

where F: FnMut(Response<ResBody>) -> Fut + Clone + Send + 'static, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, ()> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, ()> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1> Service<Request<B>> for MapResponse<F, S, I, (T1,)>

where F: FnMut(T1, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1,)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1,)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2> Service<Request<B>> for MapResponse<F, S, I, (T1, T2)>

where F: FnMut(T1, T2, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3)>

where F: FnMut(T1, T2, T3, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4)>

where F: FnMut(T1, T2, T3, T4, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5)>

where F: FnMut(T1, T2, T3, T4, T5, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6)>

where F: FnMut(T1, T2, T3, T4, T5, T6, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<F, Fut, S, I, B, ResBody, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Service<Request<B>> for MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>

where F: FnMut(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, Response<ResBody>) -> Fut + Clone + Send + 'static, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequestParts<S> + Send, T16: FromRequestParts<S> + Send, Fut: Future + Send + 'static, <Fut as Future>::Output: IntoResponse + Send + 'static, I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible> + Clone + Send + 'static, <I as Service<Request<B>>>::Future: Send + 'static, B: Send + 'static, ResBody: Send + 'static, S: Clone + Send + Sync + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<B, E> Service<Request<B>> for MethodRouter<(), B, E>

where B: Body + Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = RouteFuture<B, E>

The future response value.

fn poll_ready( &mut self, _cx: &mut Context<'_> ) -> Poll<Result<(), <MethodRouter<(), B, E> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <MethodRouter<(), B, E> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<B> Service<Request<B>> for Next<B>

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Next<B> as Service<Request<B>>>::Response, <Next<B> as Service<Request<B>>>::Error>> + Send>>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <Next<B> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<B>) -> <Next<B> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<B, E> Service<Request<B>> for Route<B, E>

where B: Body,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = RouteFuture<B, E>

The future response value.

fn poll_ready( &mut self, _cx: &mut Context<'_> ) -> Poll<Result<(), <Route<B, E> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <Route<B, E> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<B> Service<Request<B>> for Router<(), B>

where B: Body + Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = RouteFuture<B, Infallible>

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_> ) -> Poll<Result<(), <Router<(), B> as Service<Request<B>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<B> ) -> <Router<(), B> as Service<Request<B>>>::Future

Process the request and return the response asynchronously.

impl<ResBody, S, T> Service<Request<ResBody>> for AddExtension<S, T>

where S: Service<Request<ResBody>>, T: Clone + Send + Sync + 'static,

type Response = <S as Service<Request<ResBody>>>::Response

Responses given by the service.

type Error = <S as Service<Request<ResBody>>>::Error

Errors produced by the service.

type Future = <S as Service<Request<ResBody>>>::Future

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), <AddExtension<S, T> as Service<Request<ResBody>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<ResBody> ) -> <AddExtension<S, T> as Service<Request<ResBody>>>::Future

Process the request and return the response asynchronously.