Trait Service 

pub trait Service<Input>:
    Sized
    + Send
    + Sync
    + 'static {
    type Output: Send + 'static;
    type Error: Send + 'static;

    // Required method
    fn serve(
        &self,
        input: Input,
    ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send;

    // Provided method
    fn boxed(self) -> BoxService<Input, Self::Output, Self::Error> { ... }
}

A Service that produces rama services, to serve given an input, be it transport layer Inputs or application layer http requests, or something else entirely.

Required Associated Types

type Output: Send + 'static

The type of the output returned by the service.

type Error: Send + 'static

The type of error returned by the service.

Required Methods

fn serve( &self, input: Input, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send

Serve an output or an error for the given input

Provided Methods

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<Input> Service<Input> for ()

where Input: Send + 'static,

type Output = Input

type Error = Infallible

async fn serve( &self, input: Input, ) -> Result<<() as Service<Input>>::Output, <() as Service<Input>>::Error>

impl<S, Input> Service<Input> for &'static S

where S: Service<Input>,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

fn serve( &self, input: Input, ) -> impl Future<Output = Result<<&'static S as Service<Input>>::Output, <&'static S as Service<Input>>::Error>> + Send

Implementors

impl Service<Interface> for DefaultAcceptorFactory

type Output = TcpListener

type Error = Box<dyn Error + Send + Sync>

impl Service<Interface> for DefaultUdpBinder

type Output = UdpSocket

type Error = Box<dyn Error + Send + Sync>

impl Service<Upgraded> for WebSocketEchoService

type Output = ()

type Error = OpaqueError

impl Service<Request> for rama::cli::service::echo::EchoService

type Output = Response

type Error = Box<dyn Error + Send + Sync>

impl Service<Request> for GrpcRouter

type Output = Response

type Error = Infallible

impl Service<ServerWebSocket> for WebSocketEchoService

type Output = ()

type Error = OpaqueError

impl Service<AsyncWebSocket> for WebSocketEchoService

type Output = ()

type Error = OpaqueError

impl<A, B, C, D, E, F, G, H, I, Input, Output> Service<Input> for Either9<A, B, C, D, E, F, G, H, I>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, I: Service<Input, Output = Output>, <I as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, G, H, I, Input, Output> Service<Input> for EitherConn9Connected<A, B, C, D, E, F, G, H, I>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, I: Service<Input, Output = Output>, <I as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, C, D, E, F, G, H, Input, Output> Service<Input> for Either8<A, B, C, D, E, F, G, H>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, G, H, Input, Output> Service<Input> for EitherConn8Connected<A, B, C, D, E, F, G, H>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, C, D, E, F, G, Input, Output> Service<Input> for Either7<A, B, C, D, E, F, G>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, G, Input, Output> Service<Input> for EitherConn7Connected<A, B, C, D, E, F, G>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, C, D, E, F, Input, Output> Service<Input> for Either6<A, B, C, D, E, F>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, Input, Output> Service<Input> for EitherConn6Connected<A, B, C, D, E, F>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, C, D, E, Input, Output> Service<Input> for Either5<A, B, C, D, E>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, Input, Output> Service<Input> for EitherConn5Connected<A, B, C, D, E>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, C, D, Input, Output> Service<Input> for Either4<A, B, C, D>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, Input, Output> Service<Input> for EitherConn4Connected<A, B, C, D>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, C, Input, Output> Service<Input> for Either3<A, B, C>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, Input, Output> Service<Input> for EitherConn3Connected<A, B, C>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, B, Input, Output> Service<Input> for Either<A, B>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, Input, Output> Service<Input> for EitherConnConnected<A, B>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<A, C, L, S, ReqBody, ResBody> Service<Request<ReqBody>> for ProxyAuthService<A, C, S, L>

where A: Authority<C, L>, C: Credentials + Clone + Send + Sync + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, L: 'static, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

type Error = OpaqueError

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, G, ConnG, H, ConnH, I, ConnI, Input> Service<Input> for EitherConn9<A, B, C, D, E, F, G, H, I>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, D: Service<Input, Output = EstablishedClientConnection<ConnD, Input>>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnD: Send + 'static, E: Service<Input, Output = EstablishedClientConnection<ConnE, Input>>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnE: Send + 'static, F: Service<Input, Output = EstablishedClientConnection<ConnF, Input>>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnF: Send + 'static, G: Service<Input, Output = EstablishedClientConnection<ConnG, Input>>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnG: Send + 'static, H: Service<Input, Output = EstablishedClientConnection<ConnH, Input>>, <H as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnH: Send + 'static, I: Service<Input, Output = EstablishedClientConnection<ConnI, Input>>, <I as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnI: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn9Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF, ConnG, ConnH, ConnI>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, G, ConnG, H, ConnH, Input> Service<Input> for EitherConn8<A, B, C, D, E, F, G, H>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, D: Service<Input, Output = EstablishedClientConnection<ConnD, Input>>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnD: Send + 'static, E: Service<Input, Output = EstablishedClientConnection<ConnE, Input>>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnE: Send + 'static, F: Service<Input, Output = EstablishedClientConnection<ConnF, Input>>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnF: Send + 'static, G: Service<Input, Output = EstablishedClientConnection<ConnG, Input>>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnG: Send + 'static, H: Service<Input, Output = EstablishedClientConnection<ConnH, Input>>, <H as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnH: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn8Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF, ConnG, ConnH>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, G, ConnG, Input> Service<Input> for EitherConn7<A, B, C, D, E, F, G>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, D: Service<Input, Output = EstablishedClientConnection<ConnD, Input>>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnD: Send + 'static, E: Service<Input, Output = EstablishedClientConnection<ConnE, Input>>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnE: Send + 'static, F: Service<Input, Output = EstablishedClientConnection<ConnF, Input>>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnF: Send + 'static, G: Service<Input, Output = EstablishedClientConnection<ConnG, Input>>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnG: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn7Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF, ConnG>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, Input> Service<Input> for EitherConn6<A, B, C, D, E, F>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, D: Service<Input, Output = EstablishedClientConnection<ConnD, Input>>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnD: Send + 'static, E: Service<Input, Output = EstablishedClientConnection<ConnE, Input>>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnE: Send + 'static, F: Service<Input, Output = EstablishedClientConnection<ConnF, Input>>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnF: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn6Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, Input> Service<Input> for EitherConn5<A, B, C, D, E>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, D: Service<Input, Output = EstablishedClientConnection<ConnD, Input>>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnD: Send + 'static, E: Service<Input, Output = EstablishedClientConnection<ConnE, Input>>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnE: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn5Connected<ConnA, ConnB, ConnC, ConnD, ConnE>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, Input> Service<Input> for EitherConn4<A, B, C, D>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, D: Service<Input, Output = EstablishedClientConnection<ConnD, Input>>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnD: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn4Connected<ConnA, ConnB, ConnC, ConnD>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, C, ConnC, Input> Service<Input> for EitherConn3<A, B, C>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, C: Service<Input, Output = EstablishedClientConnection<ConnC, Input>>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnC: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn3Connected<ConnA, ConnB, ConnC>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<A, ConnA, B, ConnB, Input> Service<Input> for EitherConn<A, B>

where A: Service<Input, Output = EstablishedClientConnection<ConnA, Input>>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnA: Send + 'static, B: Service<Input, Output = EstablishedClientConnection<ConnB, Input>>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, ConnB: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConnConnected<ConnA, ConnB>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<B, S, Response, IO> Service<IO> for HttpService<B, S>

where B: HttpCoreConnServer, S: Service<Request, Output = Response, Error = Infallible> + Clone, Response: IntoResponse + Send + 'static, IO: Stream + ExtensionsMut,

type Output = ()

type Error = Box<dyn Error + Send + Sync>

impl<Body> Service<Request<Body>> for HttpClientService<Body>

where Body: Body + Unpin + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = Box<dyn Error + Send + Sync>

impl<Body> Service<Request<Body>> for WebSocketAcceptor

where Body: Send + 'static,

type Output = (Response, Request<Body>)

type Error = Response

impl<Body, ConnectionBody, Connection, L> Service<Request<Body>> for EasyHttpWebClient<Body, EstablishedClientConnection<Connection, Request<ConnectionBody>>, L>

where Body: StreamingBody<Data: Send + 'static, Error: Into<BoxError>> + Unpin + Send + 'static, Connection: Service<Request<ConnectionBody>, Output = Response, Error = BoxError> + ExtensionsRef, ConnectionBody: StreamingBody<Data: Send + 'static, Error: Into<BoxError>> + Unpin + Send + 'static, L: Layer<Connection, Service: Service<Request<ConnectionBody>, Output = Response, Error = BoxError>> + Send + Sync + 'static,

type Output = Response

type Error = OpaqueError

impl<Body, ResBody> Service<Request<Body>> for RedirectStatic<ResBody>

where Body: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

type Error = Infallible

impl<Body, S> Service<Request<Body>> for DnsResolveModeService<S>

where Body: Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = OpaqueError

impl<Body, S, P> Service<Request<Body>> for UserAgentEmulateService<S, P>

where Body: Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, P: UserAgentProvider,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<C, B, U, A, S> Service<S> for Socks5Acceptor<C, B, U, A>

where C: Socks5Connector<S>, U: Socks5UdpAssociator<S>, A: Authorizer<Basic>, <A as Authorizer<Basic>>::Error: Debug, B: Socks5Binder<S>, S: Stream + Unpin + ExtensionsMut,

type Output = ()

type Error = Error

impl<F, S, ReqBody, ResBody, NewReqBody> Service<Request<ReqBody>> for MapRequestBody<S, F>

where S: Service<Request<NewReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, NewReqBody: Send + 'static, ResBody: Send + Sync + 'static, F: Fn(ReqBody) -> NewReqBody + Send + Sync + 'static,

type Output = <S as Service<Request<NewReqBody>>>::Output

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

impl<F, S, ReqBody, ResBody, NewResBody> Service<Request<ReqBody>> for MapResponseBody<S, F>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + Sync + 'static, NewResBody: Send + Sync + 'static, F: Fn(ResBody) -> NewResBody + Clone + Send + Sync + 'static,

type Output = Response<NewResBody>

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

impl<F, T, State> Service<Request> for EndpointServiceFnWrapper<F, T, State>

where F: EndpointServiceFn<T, State>, T: Send + 'static, State: Send + Sync + Clone + 'static,

type Output = Response

type Error = Infallible

impl<H, S, Body> Service<Request<Body>> for GetForwardedHeaderService<S, H>

where H: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<Input> Service<Input> for MirrorService

where Input: Send + 'static,

type Output = Input

type Error = Infallible

impl<Input, C, ID> Service<Input> for LeasedConnection<C, ID>

where ID: Send + Sync + Debug + 'static, C: Service<Input> + ExtensionsMut, Input: Send + 'static,

type Output = <C as Service<Input>>::Output

type Error = <C as Service<Input>>::Error

impl<Input, ConnectorFactory> Service<Input> for UnixConnector<ConnectorFactory>

where Input: Send + 'static, ConnectorFactory: UnixStreamConnectorFactory + Clone, <ConnectorFactory as UnixStreamConnectorFactory>::Connector: UnixStreamConnector, <<ConnectorFactory as UnixStreamConnectorFactory>::Connector as UnixStreamConnector>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, <ConnectorFactory as UnixStreamConnectorFactory>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<UnixStream, Input>

type Error = Box<dyn Error + Send + Sync>

impl<Input, Dns, ConnectorFactory> Service<Input> for TcpConnector<Dns, ConnectorFactory>

where Input: TryRefIntoTransportContext + Send + ExtensionsMut + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, Dns: DnsResolver + Clone, ConnectorFactory: TcpStreamConnectorFactory + Clone, <ConnectorFactory as TcpStreamConnectorFactory>::Connector: TcpStreamConnector, <<ConnectorFactory as TcpStreamConnectorFactory>::Connector as TcpStreamConnector>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, <ConnectorFactory as TcpStreamConnectorFactory>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<TcpStream, Input>

type Error = Box<dyn Error + Send + Sync>

impl<Input, F, T, R, O, E> Service<Input> for ServiceFn<F, T, R, O, E>

where F: Factory<T, R, O, E>, R: Future<Output = Result<O, E>> + Send + 'static, T: FromInput<Input>, O: Send + 'static, E: Send + Sync + 'static,

type Output = O

type Error = E

impl<Input, Output, Error> Service<Input> for BoxService<Input, Output, Error>

where Input: 'static, Output: Send + 'static, Error: Send + 'static,

type Output = Output

type Error = Error

impl<Input, Output, Error> Service<Input> for RejectService<Output, Error>

where Input: 'static, Output: Send + 'static, Error: Clone + Send + Sync + 'static,

type Output = Output

type Error = Error

impl<Input, S> Service<Input> for ProxyConnector<S>

where S: ConnectorService<Input, Connection: Stream + Unpin>, Input: TryRefIntoTransportContext<Error: Into<BoxError> + Send + 'static> + Send + ExtensionsMut + 'static,

type Output = EstablishedClientConnection<MaybeProxiedConnection<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<Input, S, P, R> Service<Input> for PooledConnector<S, P, R>

where S: ConnectorService<Input>, Input: Send + ExtensionsRef + 'static, P: Pool<<S as ConnectorService<Input>>::Connection, <R as ReqToConnID<Input>>::ID>, R: ReqToConnID<Input>,

type Output = EstablishedClientConnection<<P as Pool<<S as ConnectorService<Input>>::Connection, <R as ReqToConnID<Input>>::ID>>::Connection, Input>

type Error = Box<dyn Error + Send + Sync>

impl<Input, S, T> Service<Input> for AddInputExtension<S, T>

where Input: Send + ExtensionsMut + 'static, S: Service<Input>, T: Clone + Send + Sync + Debug + 'static,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<Input, S, T> Service<Input> for AddOutputExtension<S, T>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsMut + 'static, T: Clone + Send + Sync + Debug + 'static,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<Input, S, T, Fut, F> Service<Input> for GetInputExtension<S, T, Fut, F>

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Clone + Send + Sync + 'static, F: Fn(T) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<Input, S, T, Fut, F> Service<Input> for GetOutputExtension<S, T, Fut, F>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsRef + 'static, T: Clone + Send + Sync + 'static, F: Fn(T) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, M_T11, T11, M_T12, T12, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), (M_T11, T11), (M_T12, T12), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, M_T10: Matcher<Input>, T10: Service<Input, Output = Output, Error = Error>, M_T11: Matcher<Input>, T11: Service<Input, Output = Output, Error = Error>, M_T12: Matcher<Input>, T12: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, M_T11, T11, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), (M_T11, T11), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, M_T10: Matcher<Input>, T10: Service<Input, Output = Output, Error = Error>, M_T11: Matcher<Input>, T11: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, M_T10: Matcher<Input>, T10: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), S)>

where Input: Send + ExtensionsMut + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<P, S, Body> Service<Request<Body>> for Retry<P, S>

where P: Policy<<S as Service<Request<RetryBody>>>::Output, <S as Service<Request<RetryBody>>>::Error>, S: Service<Request<RetryBody>>, <S as Service<Request<RetryBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Body + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Request<RetryBody>>>::Output

type Error = RetryError

impl<R> Service<Request> for StaticService<R>

where R: IntoResponse + Clone + Send + Sync + 'static,

type Output = Response

type Error = Infallible

impl<R, Body> Service<Request<Body>> for RedirectHttpToHttps<R>

where R: UriMatchReplace + Send + Sync + 'static, Body: Send + 'static,

type Output = Response

type Error = Infallible

impl<R, S, W, ReqBody, ResBody> Service<Request<ReqBody>> for HARExportService<R, S, W>

where R: Recorder, S: Service<Request, Output = Response<ResBody>>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, W: Toggle, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = Box<dyn Error + Send + Sync>

impl<Req, S, T> Service<Req> for Layered<S, T>

where S: Service<Req>, Req: Send + 'static, T: Send + Sync + 'static,

type Output = <S as Service<Req>>::Output

type Error = <S as Service<Req>>::Error

impl<ReqBody> Service<Request<ReqBody>> for DefaultServeDirFallback

where ReqBody: Send + 'static,

type Output = Response

type Error = Infallible

impl<ReqBody> Service<Request<ReqBody>> for ServeFile

where ReqBody: Send + 'static,

type Error = <ServeDir as Service<Request<ReqBody>>>::Error

type Output = <ServeDir as Service<Request<ReqBody>>>::Output

impl<ReqBody, F, FResBody> Service<Request<ReqBody>> for ServeDir<F>

where ReqBody: Send + 'static, F: Service<Request<ReqBody>, Output = Response<FResBody>, Error = Infallible> + Clone, FResBody: Body<Data = Bytes> + Send + Sync + 'static, <FResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = Infallible

impl<ReqBody, R, S> Service<Request<ReqBody>> for RewriteUriService<R, S>

where S: Service<Request<ReqBody>>, R: UriMatchReplace + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, R, S> Service<Request<ReqBody>> for UriMatchRedirectService<R, S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, R: UriMatchReplace + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for PropagateHeader<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for RemoveRequestHeader<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for RemoveResponseHeader<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for AddRequiredRequestHeaders<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Request<ReqBody>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for AddRequiredResponseHeaders<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for SetSensitiveRequestHeaders<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for SetSensitiveResponseHeaders<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetRequestHeader<S, M>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeHeaderValue<ReqBody>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetResponseHeader<S, M>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeHeaderValueFactory<ReqBody, ResBody>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for StreamCompression<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<StreamCompressionBody<ResBody>>

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

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for Compression<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<CompressionBody<ResBody>>

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

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for FollowRedirect<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Body + Default + Send + 'static, ResBody: Send + 'static, P: Policy<ReqBody, <S as Service<Request<ReqBody>>>::Error> + Clone,

type Output = Response<ResBody>

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

impl<ReqBody, ServiceResBody, ValidateResBody, S, V> Service<Request<ReqBody>> for ValidateRequestHeader<S, V>

where ReqBody: Send + 'static, ServiceResBody: Send + 'static, ValidateResBody: From<ServiceResBody> + Send + 'static, V: ValidateRequest<ReqBody, ResponseBody = ValidateResBody>, S: Service<Request<ReqBody>, Output = Response<ServiceResBody>>,

type Output = Response<ValidateResBody>

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

impl<S> Service<S> for DiscardService

where S: Stream + 'static,

type Output = u64

type Error = Box<dyn Error + Send + Sync>

impl<S> Service<S> for rama::net::stream::service::EchoService

where S: Stream + 'static,

type Output = u64

type Error = Box<dyn Error + Send + Sync>

impl<S, B1, B2> Service<Request<B1>> for GrpcWebClientService<S>

where S: Service<Request<GrpcWebCall<B1>>, Output = Response<B2>>, <S as Service<Request<GrpcWebCall<B1>>>>::Error: Into<Box<dyn Error + Send + Sync>>, B1: Send + 'static, B2: Send + 'static,

type Output = Response<GrpcWebCall<B2>>

type Error = OpaqueError

impl<S, Body> Service<Request<Body>> for HttpProxyAddressService<S>

where S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for SetProxyAuthHttpHeaderService<S>

where S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for ErrorHandler<S>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Output: IntoResponse, <S as Service<Request<Body>>>::Error: IntoResponse, Body: Send + 'static,

type Output = Response

type Error = Infallible

impl<S, Body> Service<Request<Body>> for RequestVersionAdapter<S>

where S: ConnectorService<Request<Body>>, <S as ConnectorService<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Request<Body>>>::Connection, Request<Body>>

type Error = Box<dyn Error + Send + Sync>

impl<S, Body> Service<Request<Body>> for ResponseVersionAdapter<S>

where S: Service<Request<Body>, Output = Response>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, Body> Service<Request<Body>> for WebSocketAcceptorService<S>

where S: Clone + Service<ServerWebSocket, Output = ()>, Body: Send + 'static,

type Output = Response

type Error = <S as Service<ServerWebSocket>>::Error

impl<S, Body> Service<Request<Body>> for UserAgentClassifier<S>

where S: Service<Request<Body>>,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, BodyIn, BodyConnection> Service<Request<BodyIn>> for HttpConnector<S, BodyConnection>

where S: ConnectorService<Request<BodyIn>>, <S as ConnectorService<Request<BodyIn>>>::Connection: Stream + Unpin, BodyIn: Body + Unpin + Send + 'static, <BodyIn as Body>::Data: Send + 'static, <BodyIn as Body>::Error: Into<Box<dyn Error + Send + Sync>>, BodyConnection: Body + Unpin + Send + 'static, <BodyConnection as Body>::Data: Send + 'static, <BodyConnection as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = EstablishedClientConnection<HttpClientService<BodyConnection>, Request<BodyIn>>

type Error = Box<dyn Error + Send + Sync>

impl<S, D, P, F, Input> Service<Input> for ProxyDBService<S, D, P, F>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, D: ProxyDB, <D as ProxyDB>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, P: ProxyQueryPredicate, F: UsernameFormatter, Input: TryRefIntoTransportContext + ExtensionsMut + Send + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, F, Body> Service<Request<Body>> for RequestMetricsService<S, F>

where S: Service<Request>, <S as Service<Request>>::Output: IntoResponse, F: AttributesFactory, Body: Body<Data = Bytes> + Send + Sync + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<S, F, Input1, Input2> Service<Input1> for MapInput<S, F>

where S: Service<Input2>, F: Fn(Input1) -> Input2 + Send + Sync + 'static,

type Output = <S as Service<Input2>>::Output

type Error = <S as Service<Input2>>::Error

impl<S, F, Input> Service<Input> for ConsumeErr<S, F>

where S: Service<Input>, <S as Service<Input>>::Output: Default, F: Fn(<S as Service<Input>>::Error) + Send + Sync + 'static, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Infallible

impl<S, F, Input, Error> Service<Input> for MapErr<S, F>

where S: Service<Input>, F: Fn(<S as Service<Input>>::Error) -> Error + Send + Sync + 'static, Input: Send + 'static, Error: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Error

impl<S, F, Input, Output> Service<Input> for MapOutput<S, F>

where S: Service<Input>, F: Fn(<S as Service<Input>>::Output) -> Output + Send + Sync + 'static, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <S as Service<Input>>::Error

impl<S, F, Input, Output, Error> Service<Input> for MapResult<S, F>

where S: Service<Input>, F: Fn(Result<<S as Service<Input>>::Output, <S as Service<Input>>::Error>) -> Result<Output, Error> + Send + Sync + 'static, Input: Send + 'static, Output: Send + 'static, Error: Send + 'static,

type Output = Output

type Error = Error

impl<S, F, Input, R> Service<Input> for ConsumeErr<S, F, StaticOutput<R>>

where S: Service<Input>, F: Fn(<S as Service<Input>>::Error) + Send + Sync + 'static, R: Into<<S as Service<Input>>::Output> + Clone + Send + Sync + 'static, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Infallible

impl<S, F, R, Body> Service<Request<Body>> for ErrorHandler<S, F>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Output: IntoResponse, F: Fn(<S as Service<Request<Body>>>::Error) -> R + Clone + Send + Sync + 'static, R: IntoResponse + 'static, Body: Send + 'static,

type Output = Response

type Error = Infallible

impl<S, F, Stream> Service<Stream> for NetworkMetricsService<S, F>

where S: Service<Stream>, F: AttributesFactory, Stream: Stream + ExtensionsRef,

type Output = <S as Service<Stream>>::Output

type Error = <S as Service<Stream>>::Error

impl<S, H, Body> Service<Request<Body>> for SetForwardedHeaderService<S, H>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, H: ForwardHeader + Send + Sync + 'static, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, H, M, Input> Service<Input> for HijackService<S, H, M>

where S: Service<Input>, H: Service<Input>, <H as Service<Input>>::Output: Into<<S as Service<Input>>::Output>, <H as Service<Input>>::Error: Into<<S as Service<Input>>::Error>, M: Matcher<Input>, Input: Send + ExtensionsMut + 'static,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<S, I, ReqBody, ResBody> Service<Request<ReqBody>> for InterceptedService<S, I>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, I: Service<Request<()>, Output = Request<()>, Error = Status>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, IO> Service<IO> for rama::net::stream::layer::http::BodyLimitService<S>

where S: Service<IO>, IO: Stream + ExtensionsMut,

type Output = <S as Service<IO>>::Output

type Error = <S as Service<IO>>::Error

impl<S, IO> Service<IO> for IncomingBytesTrackerService<S>

where S: Service<BytesRWTracker<IO>>, IO: Stream + ExtensionsMut,

type Output = <S as Service<BytesRWTracker<IO>>>::Output

type Error = <S as Service<BytesRWTracker<IO>>>::Error

impl<S, IO> Service<IO> for rama::proxy::haproxy::server::HaProxyService<S>

where S: Service<PeekStream<HeapReader, IO>>, <S as Service<PeekStream<HeapReader, IO>>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: Stream + Unpin + ExtensionsMut,

type Output = <S as Service<PeekStream<HeapReader, IO>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, IO> Service<IO> for rama::tls::boring::server::TlsAcceptorService<S>

where IO: Stream + Unpin + ExtensionsMut + 'static, S: Service<TlsStream<IO>>, <S as Service<TlsStream<IO>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<TlsStream<IO>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, IO> Service<IO> for rama::tls::rustls::server::TlsAcceptorService<S>

where IO: Stream + Unpin + ExtensionsMut + 'static, S: Service<TlsStream<IO>>, <S as Service<TlsStream<IO>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<TlsStream<IO>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for HttpProxyConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: TryRefIntoTransportContext + Send + ExtensionsMut + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<MaybeHttpProxiedConnection<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for ConsumeErr<S, Trace>

where S: Service<Input>, <S as Service<Input>>::Output: Default, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Infallible

impl<S, Input> Service<Input> for TraceErr<S>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Error: Display + Send + Sync + 'static,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<S, Input> Service<Input> for OutgoingBytesTrackerService<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: Send + 'static,

type Output = EstablishedClientConnection<BytesRWTracker<<S as ConnectorService<Input>>::Connection>, Input>

type Error = <S as ConnectorService<Input>>::Error

impl<S, Input> Service<Input> for Socks5ProxyConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: TryRefIntoTransportContext + Send + ExtensionsMut + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for EmulateTlsProfileService<S>

where Input: TryRefIntoTransportContext + Send + ExtensionsMut + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>>, S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Input>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for rama::tls::boring::client::TlsConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: TryRefIntoTransportContext + Send + ExtensionsMut + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for rama::tls::boring::client::TlsConnector<S, ConnectorKindSecure>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: TryRefIntoTransportContext + Send + ExtensionsMut + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<TlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for rama::tls::boring::client::TlsConnector<S, ConnectorKindTunnel>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: Send + ExtensionsMut + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for rama::tls::rustls::client::TlsConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: TryRefIntoTransportContext + ExtensionsRef + Send + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for rama::tls::rustls::client::TlsConnector<S, ConnectorKindSecure>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: TryRefIntoTransportContext + Send + ExtensionsRef + 'static, <Input as TryRefIntoTransportContext>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<TlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for rama::tls::rustls::client::TlsConnector<S, ConnectorKindTunnel>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Unpin, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, Input> Service<Input> for Box<S>

where S: Service<Input>,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<S, Input> Service<Input> for Arc<S>

where S: Service<Input>,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<S, Input, R> Service<Input> for ConsumeErr<S, Trace, StaticOutput<R>>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, R: Into<<S as Service<Input>>::Output> + Clone + Send + Sync + 'static, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Infallible

impl<S, Input, Server> Service<Input> for MockConnectorService<S>

where S: Fn() -> Server + Send + Sync + 'static, Server: Service<MockSocket>, <Server as Service<MockSocket>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static,

type Error = Infallible

type Output = EstablishedClientConnection<MockSocket, Input>

impl<S, Input, Svc> Service<Input> for BoxedConnectorService<S>

where S: Service<Input, Output = EstablishedClientConnection<Svc, Input>>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Svc: Service<Input>, Input: Send + 'static,

type Output = EstablishedClientConnection<BoxService<Input, <Svc as Service<Input>>::Output, <Svc as Service<Input>>::Error>, Input>

type Error = <S as Service<Input>>::Error

impl<S, L, Input> Service<Input> for MaybeLayeredService<S, L>

where S: Service<Input>, L: Layer<S> + 'static, <L as Layer<S>>::Service: Service<Input, Output = <S as Service<Input>>::Output>, <<L as Layer<S>>::Service as Service<Input>>::Error: Into<<S as Service<Input>>::Error>, Input: Send + 'static,

type Error = <S as Service<Input>>::Error

type Output = <S as Service<Input>>::Output

impl<S, M, ReqBody, ResBody> Service<Request<ReqBody>> for SetRequestId<S, M>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeRequestId, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, O, E> Service<Request> for UpgradeService<S, O>

where S: Service<Request, Output = O, Error = E>, O: Send + Sync + 'static, E: Send + Sync + 'static,

type Output = O

type Error = E

impl<S, P, Input> Service<Input> for UsernameLabelParserService<S, P>

where S: Service<Input>, P: UsernameLabelParser, Input: ExtensionsMut,

type Output = <S as Service<Input>>::Output

type Error = <S as Service<Input>>::Error

impl<S, P, Input> Service<Input> for rama::proxy::haproxy::client::HaProxyService<S, P>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Socket + Unpin, P: Protocol + Send + 'static, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, P, Input> Service<Input> for rama::proxy::haproxy::client::HaProxyService<S, P, One>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Stream + Socket + Unpin, P: Send + 'static, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = Box<dyn Error + Send + Sync>

impl<S, R> Service<Request> for MapResponseServie<S>

where S: Service<Request, Output = R, Error = Infallible>, R: IntoResponse + Send + Sync + 'static,

type Output = Response

type Error = Infallible

impl<S, Req, ResBody> Service<Req> for RecoverError<S>

where S: Service<Req, Output = Response<ResBody>>, <S as Service<Req>>::Error: Into<Box<dyn Error + Send + Sync>>, Req: Send + 'static, ResBody: Send + Sync + 'static,

type Output = Response<OptionalBody<ResBody>>

type Error = Box<dyn Error + Send + Sync>

impl<S, ReqBody> Service<Request<ReqBody>> for GrpcTimeout<S>

where S: Service<Request<ReqBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, ReqBody> Service<Request<ReqBody>> for rama::http::layer::body_limit::BodyLimitService<S>

where S: Service<Request>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Request>>::Output

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

impl<S, ReqBody> Service<Request<ReqBody>> for RequestBodyTimeout<S>

where S: Service<Request<TimeoutBody<ReqBody>>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<TimeoutBody<ReqBody>>>>::Output

type Error = <S as Service<Request<TimeoutBody<ReqBody>>>>::Error

impl<S, ReqBody> Service<Request<ReqBody>> for UserAgentEmulateHttpConnectModifier<S>

where S: ConnectorService<Request<ReqBody>>, <S as ConnectorService<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static,

type Error = Box<dyn Error + Send + Sync>

type Output = EstablishedClientConnection<<S as ConnectorService<Request<ReqBody>>>::Connection, Request<ReqBody>>

impl<S, ReqBody> Service<Request<ReqBody>> for UserAgentEmulateHttpRequestModifier<S>

where S: Service<Request<ReqBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static,

type Error = Box<dyn Error + Send + Sync>

type Output = <S as Service<Request<ReqBody>>>::Output

impl<S, ReqBody, R> Service<Request<ReqBody>> for RamaHttpService<S>

where S: Service<Request, Output = R, Error = Infallible>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, R: IntoResponse + Send + 'static,

type Output = Response

type Error = Infallible

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for GrpcWebService<S>

where S: Service<Request, Output = Response<ResBody>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Display, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Display,

type Output = Response

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for AddAuthorization<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for CollectBody<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static, ResBody: Body + Send + Sync + 'static, <ResBody as Body>::Data: Send, <ResBody as Body>::Error: Error + Send + Sync + 'static,

type Output = Response

type Error = Box<dyn Error + Send + Sync>

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for Cors<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for Decompression<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static,

type Output = Response<DecompressionBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for RequestDecompression<S>

where S: Service<Request<DecompressionBody<ReqBody>>, Output = Response<ResBody>>, <S as Service<Request<DecompressionBody<ReqBody>>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Body + Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = Box<dyn Error + Send + Sync>

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for NormalizePath<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for PropagateRequestId<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for SetStatus<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseBodyTimeout<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<TimeoutBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for rama::http::layer::timeout::Timeout<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, ReqBody, ResBody, M, OnRequestT, OnResponseT, OnFailureT, OnBodyChunkT, OnEosT, MakeSpanT> Service<Request<ReqBody>> for Trace<S, M, MakeSpanT, OnRequestT, OnResponseT, OnBodyChunkT, OnEosT, OnFailureT>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Display, ReqBody: Body + Send + 'static, ResBody: Body + Send + Sync + 'static, <ResBody as Body>::Error: Display, M: MakeClassifier, <M as MakeClassifier>::Classifier: Clone, MakeSpanT: MakeSpan<ReqBody>, OnRequestT: OnRequest<ReqBody>, OnResponseT: OnResponse<ResBody> + Clone, OnBodyChunkT: OnBodyChunk<<ResBody as Body>::Data> + Clone, OnEosT: OnEos + Clone, OnFailureT: OnFailure<<M as MakeClassifier>::FailureClass> + Clone,

type Output = Response<ResponseBody<ResBody, <M as MakeClassifier>::ClassifyEos, OnBodyChunkT, OnEosT, OnFailureT>>

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

impl<S, T1, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1,)>

where T1: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, T7, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<S, T> Service<ProxyRequest<S, T>> for StreamForwardService

where S: Stream + Unpin, T: Stream + Unpin,

type Output = ()

type Error = OpaqueError

impl<S, T, ReqBody, ResBody> Service<Request<ReqBody>> for CatchPanic<S, T>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Into<Body> + Send + 'static, T: ResponseForPanic + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response

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

impl<S, W, ReqBody> Service<Request<ReqBody>> for RequestWriterService<S, W>

where S: Service<Request>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, W: RequestWriter,

type Error = Box<dyn Error + Send + Sync>

type Output = <S as Service<Request>>::Output

impl<S, W, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseWriterService<S, W>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, W: ResponseWriter, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = Box<dyn Error + Send + Sync>

impl<State> Service<Request> for Router<State>

where State: Send + Sync + Clone + 'static,

type Output = Response

type Error = Infallible

impl<State> Service<Request> for WebService<State>

where State: Send + Sync + Clone + 'static,

type Output = Response

type Error = Infallible

impl<Stream, Output, S, F> Service<Stream> for SniRouter<S, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, S: Service<SniRequest<Stream>, Output = Output>, <S as Service<SniRequest<Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_net::::tls::server::peek::TlsPeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_net::::tls::server::peek::TlsPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<Stream, Output, T, F> Service<Stream> for HttpPeekRouter<H2Acceptor<T>, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, T: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <T as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<Stream, Output, T, F> Service<Stream> for HttpPeekRouter<Http1Acceptor<T>, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, T: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <T as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<Stream, Output, T, F> Service<Stream> for HttpPeekRouter<HttpAutoAcceptor<T>, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, T: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <T as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<Stream, Output, T, F> Service<Stream> for TlsPeekRouter<T, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, T: Service<PeekStream<StackReader<rama_net::::tls::server::peek::TlsPeekStream::{constant#0}>, Stream>, Output = Output>, <T as Service<PeekStream<StackReader<rama_net::::tls::server::peek::TlsPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_net::::tls::server::peek::TlsPeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_net::::tls::server::peek::TlsPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<Stream, Output, T, F> Service<Stream> for Socks5PeekRouter<T, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, T: Service<PeekStream<StackReader<rama_socks5::::server::peek::Socks5PeekStream::{constant#0}>, Stream>, Output = Output>, <T as Service<PeekStream<StackReader<rama_socks5::::server::peek::Socks5PeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_socks5::::server::peek::Socks5PeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_socks5::::server::peek::Socks5PeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<Stream, Output, T, U, F> Service<Stream> for HttpPeekRouter<HttpDualAcceptor<T, U>, F>

where Stream: Stream + Unpin + ExtensionsMut, Output: Send + 'static, T: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <T as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, U: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <U as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>, Output = Output>, <F as Service<PeekStream<StackReader<rama_net::::http::server::peek::HttpPeekStream::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

type Error = Box<dyn Error + Send + Sync>

impl<T1, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1,)>

where T1: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T, B> Service<Request<B>> for HealthServer<T>

where T: Health, B: Body + Send + Sync + 'static, <B as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = Response

type Error = Infallible

impl<T, C> Service<T> for Forwarder<C>

where T: Stream + Unpin + ExtensionsMut, C: ConnectorService<Request>, <C as ConnectorService<Request>>::Connection: Stream + Unpin,

type Output = ()

type Error = Box<dyn Error + Send + Sync>

impl<T, F, Input, E> Service<Input> for rama::layer::Timeout<T, F>

where Input: Send + 'static, F: MakeLayerError<Error = E>, E: Into<<T as Service<Input>>::Error> + Send + 'static, T: Service<Input>,

type Output = <T as Service<Input>>::Output

type Error = <T as Service<Input>>::Error

impl<T, Input> Service<Input> for LayerAdapterService<T>

where T: Service<Input> + Clone + Send + Sync + 'static, <T as Service<Input>>::Response: Send + 'static, <T as Service<Input>>::Error: Send + 'static, <T as Service<Input>>::Future: Send, Input: Send + 'static,

type Output = <T as Service<Input>>::Response

type Error = <T as Service<Input>>::Error

impl<T, Input> Service<Input> for ServiceAdapter<T>

where T: Service<Input> + Clone + Send + Sync + 'static, <T as Service<Input>>::Response: Send + 'static, <T as Service<Input>>::Error: Send + 'static, <T as Service<Input>>::Future: Send, Input: Send + 'static,

type Output = <T as Service<Input>>::Response

type Error = <T as Service<Input>>::Error

impl<T, Input> Service<Input> for SharedServiceAdapter<T>

where T: Service<Input> + Send + Sync + 'static, <T as Service<Input>>::Response: Send + 'static, <T as Service<Input>>::Error: Send + 'static, <T as Service<Input>>::Future: Send, Input: Send + 'static,

type Output = <T as Service<Input>>::Response

type Error = <T as Service<Input>>::Error

impl<T, P, F, Input, FnOutput, FnError> Service<Input> for Limit<T, P, ErrorIntoOutputFn<F>>

where T: Service<Input>, P: Policy<Input>, F: Fn(<P as Policy<Input>>::Error) -> Result<FnOutput, FnError> + Send + Sync + 'static, FnOutput: Into<<T as Service<Input>>::Output> + Send + 'static, FnError: Into<<T as Service<Input>>::Error> + Send + Sync + 'static, Input: Send + Sync + 'static,

type Output = <T as Service<Input>>::Output

type Error = <T as Service<Input>>::Error

impl<T, P, Input> Service<Input> for Limit<T, P>

where T: Service<Input>, <T as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Policy<Input>, <P as Policy<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + Sync + 'static,

type Output = <T as Service<Input>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<T, S, Body, E> Service<Request<Body>> for HeaderConfigService<T, S>

where S: Service<Request<Body>, Error = E>, T: DeserializeOwned + Clone + Send + Sync + Debug + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<T, S, Body, E> Service<Request<Body>> for HeaderOptionValueService<T, S>

where S: Service<Request<Body>, Error = E>, T: Default + Clone + Send + Sync + Debug + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>

impl<T, S, Body, E, C> Service<Request<Body>> for HeaderFromStrConfigService<T, S, C>

where S: Service<Request<Body>, Error = E>, T: FromStr + Send + Sync + Clone + Debug + 'static, <T as FromStr>::Err: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, C: FromIterator<T> + Send + Sync + Clone + Debug + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

type Error = Box<dyn Error + Send + Sync>