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".

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<AsyncWebSocket> for WebSocketEchoService

type Output = ()

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

impl Service<FastCgiClientRequest> for FastCgiTcpConnector

type Output = EstablishedClientConnection<TcpStream, FastCgiClientRequest>

type Error = ConnectionError

impl Service<FastCgiClientRequest> for FastCgiUnixConnector

type Output = EstablishedClientConnection<UnixStream, FastCgiClientRequest>

type Error = ConnectionError

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

Available on crate features cli and haproxy and http and net and std only.

type Output = Response

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

impl Service<Request> for GrpcRouter

type Output = Response

type Error = Infallible

impl Service<ServerWebSocket> for WebSocketEchoService

type Output = ()

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

impl Service<SocketAddress> for DefaultAcceptorFactory

type Output = TcpListener

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

impl Service<SocketAddress> for DefaultUdpBinder

type Output = UdpSocket

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

impl Service<Upgraded> for WebSocketEchoService

type Output = ()

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

impl Service<Uri> for FetchPacScript

type Output = PacScript

type Error = OpaqueError

impl Service<Uri> for StaticPacScript

type Output = PacScript

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, I: Service<Input, Output = Output>, <I as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

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 + Sync + Send>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, T, EA, EB> Service<StreamBridge<A, B>> for StreamForwardService

where A: Stream<Item = Result<T, EA>> + Sink<T, Error = EA> + Send + Unpin + 'static, B: Stream<Item = Result<T, EB>> + Sink<T, Error = EB> + Send + Unpin + 'static, T: Send + 'static, EA: Into<Box<dyn Error + Sync + Send>> + Send + 'static, EB: Into<Box<dyn Error + Sync + Send>> + Send + 'static,

type Output = BridgeCloseReason

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

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

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

type Output = Response<OptionalBody<ResBody>>

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

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: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, G: ConnectorService<Input, Connection = ConnG>, ConnG: Send + 'static, H: ConnectorService<Input, Connection = ConnH>, ConnH: Send + 'static, I: ConnectorService<Input, Connection = ConnI>, ConnI: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, G: ConnectorService<Input, Connection = ConnG>, ConnG: Send + 'static, H: ConnectorService<Input, Connection = ConnH>, ConnH: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, G: ConnectorService<Input, Connection = ConnG>, ConnG: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, Input: Send + 'static,

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

type Error = ConnectionError

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: Io + ExtensionsRef,

type Output = ()

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

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,

Available on crate features dns and http-backend and http and std and tcp only.

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, 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 + Sync + Send>>, P: UserAgentProvider,

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

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

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 + Sync + Send>> + Send + Sync + 'static,

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

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

impl<Body> Service<Request<Body>> for DefaultHttpProxyConnectReplyService

where Body: Send + 'static,

type Output = UpgradeResponse<Request<Body>, Response>

type Error = Response

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 + Sync + Send>>,

type Output = Response

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

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

where Body: Send + 'static,

type Output = UpgradeResponse<Request<Body>, Response>

type Error = Response

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: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = Error

impl<C, Input> Service<Input> for TtrpcConnector<C>

where C: ConnectorService<Input>, <C as ConnectorService<Input>>::Connection: Io, Input: Send + 'static,

type Output = EstablishedClientConnection<Client, Input>

type Error = ConnectionError

impl<C, ReqBody, RespBody> Service<Request<ReqBody>> for BindBodyToConn<C>

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

type Output = Response

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

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 = <F as Sealed<T, State>>::Output

type Error = <F as Sealed<T, State>>::Error

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<I, F, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for Socks5MitmRelayService<I, F>

where I: Service<BridgeIo<Ingress, Egress>>, <I as Service<BridgeIo<Ingress, Egress>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<BridgeIo<Ingress, Egress>>, <F as Service<BridgeIo<Ingress, Egress>>>::Error: Into<Box<dyn Error + Sync + Send>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

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

impl<I, O> Service<I> for StaticOutput<O>

where I: Send + 'static, O: Clone + Send + Sync + 'static,

type Output = O

type Error = Infallible

impl<IO> Service<IO> for TtrpcServer

where IO: Io,

type Output = ()

type Error = Error

impl<Ingress, Egress, M> Service<BridgeIo<Ingress, Egress>> for HttpMitmRelay<M>

where Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef, M: Layer<HttpClientService<Body>> + Send + Sync + 'static + Clone, <M as Layer<HttpClientService<Body>>>::Service: Service<Request, Output = Response> + Clone, <<M as Layer<HttpClientService<Body>>>::Service as Service<Request>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = ()

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

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

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

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

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

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

where C: Service<Input> + ExtensionsRef, ID: Send + Sync + 'static, 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 + Sync + Send>> + Send + 'static, <ConnectorFactory as UnixStreamConnectorFactory>::Error: Into<Box<dyn Error + Sync + Send>> + Send + 'static,

type Output = EstablishedClientConnection<UnixStream, Input>

type Error = ConnectionError

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, 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> + Extension, R: ReqToConnID<Input>,

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

type Error = ConnectionError

impl<Input, S, T, F> Service<Input> for GetInputExtensionRef<S, T, F>

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Extension, F: Fn(&T) + Send + Sync + 'static,

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

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

impl<Input, S, T, F> Service<Input> for GetOutputExtensionRef<S, T, F>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsRef + 'static, T: Extension, F: Fn(&T) + Send + Sync + 'static,

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

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

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

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Extension, F: Fn(Arc<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 GetOutputExtensionOwned<S, T, Fut, F>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsRef + 'static, T: Extension, F: Fn(Arc<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> Service<Input> for AddInputExtension<S, T>

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Extension,

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 + ExtensionsRef + 'static, T: Extension,

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

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

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

where S: ConnectorService<Input, Connection: Io + Unpin>, Input: AuthorityInputExt + ProtocolInputExt + Send + ExtensionsRef + 'static,

Available on crate features dns and http-backend and http and std and tcp only.

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

type Error = ConnectionError

impl<Input, StreamConnector> Service<Input> for TcpConnector<StreamConnector>

where Input: ConnectorTargetInputExt + TransportProtocolInputExt + Send + 'static, StreamConnector: TcpStreamConnector + Send + 'static, <StreamConnector as TcpStreamConnector>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = EstablishedClientConnection<TcpStream, Input>

type Error = ConnectionError

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

where Input: ExtensionsRef + PathInputExt + Send + 'static, T: Service<Input>,

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

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

impl<Input> Service<Input> for MirrorService

where Input: Send + 'static,

type Output = Input

type Error = Infallible

impl<Issuer, Inner, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for TlsMitmRelayService<Issuer, Inner>

where Issuer: BoringMitmCertIssuer, <Issuer as BoringMitmCertIssuer>::Error: Into<Box<dyn Error + Sync + Send>>, Inner: Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>, <Inner as Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>>::Error: Into<Box<dyn Error + Sync + Send>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = TlsMitmRelayError

impl<Issuer, Inner, Ingress, Egress> Service<InputWithClientHello<BridgeIo<Ingress, Egress>>> for TlsMitmRelayService<Issuer, Inner>

where Issuer: BoringMitmCertIssuer, <Issuer as BoringMitmCertIssuer>::Error: Into<Box<dyn Error + Sync + Send>>, Inner: Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>, <Inner as Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>>::Error: Into<Box<dyn Error + Sync + Send>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = TlsMitmRelayError

impl<M, S, ReqBody, ModReqBody, ResBody, ModResBody> Service<Request<ReqBody>> for HttpUpgradeMitmRelay<M, S>

where <M as ServiceMatcher<Request<ReqBody>>>::Error: IntoResponse, <M as ServiceMatcher<Request<ReqBody>>>::Service: ServiceMatcher<Response<ResBody>, ModifiedInput = Response<ModResBody>>, <<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Error: Into<<S as Service<Request>>::Error>, <<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Service: Service<BridgeIo<Upgraded, Upgraded>>, <<<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Service as Service<BridgeIo<Upgraded, Upgraded>>>::Error: Into<Box<dyn Error + Sync + Send>>, S: Service<Request, Output = Response<ResBody>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>, ModReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ModReqBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>, ModResBody: Body<Data = Bytes> + Send + Sync + 'static, M: ServiceMatcher<Request<ReqBody>, ModifiedInput = Request<ModReqBody>>, <ModResBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Response

type Error = <S as Service<Request>>::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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + ExtensionsRef + '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 + Sync + Send>>, Body: Body + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

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

type Error = RetryError

impl<PeekableInput, Output, S, F> Service<PeekableInput> for PeekTlsClientHelloService<S, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, S: Service<InputWithClientHello<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>>, Output = Output>, <S as Service<InputWithClientHello<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, U: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <U as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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 + Sync + Send>> + Send + Sync + 'static, W: Toggle, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Response

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

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, 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 + Sync + Send>>,

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 + Sync + Send>>,

type Output = Response

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 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, 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> 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 + Sync + Send>>,

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

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

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 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 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, 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<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<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 + Sync + Send>>, B1: Send + 'static, B2: Send + 'static,

type Output = Response<GrpcWebCall<B2>>

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

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: Into<ErrorResponse>, Body: Send + 'static,

type Output = Response

type Error = Infallible

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

where S: ConnectorService<ConnectRequest>, Body: Send + 'static,

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

type Error = ConnectionError

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 PacProxyRoutesService<S>

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

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

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

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

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

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

type Error = ConnectionError

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 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, 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, C, Input> Service<Input> for CountInput<S, C>

where S: Service<Input>, C: InputCounter, Input: ExtensionsRef + Send + 'static,

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

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

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 + Sync + Send>> + Send + Sync + 'static, D: ProxyDB, <D as ProxyDB>::Error: Into<Box<dyn Error + Sync + Send>> + Send + Sync + 'static, P: ProxyQueryPredicate, F: UsernameFormatter, Input: TransportProtocolInputExt + ExtensionsRef + Send + 'static,

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

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

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 + Sync + Send>>,

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, 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, 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, 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, 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, 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, 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: Io + 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 + Sync + Send>>, H: ForwardHeader + Send + Sync + 'static, Body: Send + 'static,

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

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

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 + ExtensionsRef + 'static,

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

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

impl<S, H, ReqBody, ResBody> Service<Request<ReqBody>> for HtmlRewrite<S, H>

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

type Output = Response<HtmlRewriteBody<ResBody, H>>

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

impl<S, H, ReqBody, ResBody> Service<Request<ReqBody>> for JsonRewrite<S, H>

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

type Output = Response<JsonRewriteBody<ResBody, H>>

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

impl<S, H, ReqBody> Service<Request<ReqBody>> for JsonRequestRewrite<S, H>

where S: Service<Request<JsonRewriteBody<ReqBody, H>>>, ReqBody: Body + Send + 'static, <ReqBody as Body>::Data: Send + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Sync + Send>> + Send + 'static, H: JsonValueHandler + Clone + Send + Sync + 'static,

type Output = <S as Service<Request<JsonRewriteBody<ReqBody, H>>>>::Output

type Error = <S as Service<Request<JsonRewriteBody<ReqBody, H>>>>::Error

impl<S, I, E> Service<I> for IntoErr<S, E>

where S: Service<I>, <S as Service<I>>::Error: Into<E>, I: Send + 'static, E: Send + 'static,

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

type Error = E

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, I> Service<I> for IntoResponseService<S>

where S: Service<I>, <S as Service<I>>::Output: IntoResponse, I: Send + 'static,

type Output = Response

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

impl<S, IO> Service<FastCgiClientRequest> for FastCgiClient<S>

where S: Service<FastCgiClientRequest, Output = EstablishedClientConnection<IO, FastCgiClientRequest>>, <S as Service<FastCgiClientRequest>>::Error: Into<Box<dyn Error + Sync + Send>>, IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Output = FastCgiClientResponse

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

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

where S: Service<IO>, IO: Io + ExtensionsRef,

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

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

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

where S: Service<FastCgiRequest, Output = FastCgiResponse>, <S as Service<FastCgiRequest>>::Error: Into<Box<dyn Error + Sync + Send>>, IO: Io + Unpin + Send + 'static,

type Output = ()

type Error = Error

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

where S: Service<GracefulIo<WaitForCancellationFutureOwned, IO>>, IO: Io + ExtensionsRef,

type Output = <S as Service<GracefulIo<WaitForCancellationFutureOwned, IO>>>::Output

type Error = <S as Service<GracefulIo<WaitForCancellationFutureOwned, IO>>>::Error

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

where S: Service<PrefixedIo<HeapReader, IO>>, <S as Service<PrefixedIo<HeapReader, IO>>>::Error: Into<Box<dyn Error + Sync + Send>>, IO: Io + Unpin + ExtensionsRef,

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

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

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

where S: Service<BytesRWTracker<IO>>, IO: Io + ExtensionsRef,

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

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

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

where S: Service<ThrottledIo<IO>>, IO: Io,

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

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

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

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

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

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

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

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

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

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

impl<S, IO> Service<Request> for FastCgiHttpClient<S>

where S: Service<FastCgiClientRequest, Output = EstablishedClientConnection<IO, FastCgiClientRequest>>, <S as Service<FastCgiClientRequest>>::Error: Into<Box<dyn Error + Sync + Send>>, IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Output = Response

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

impl<S, IO> Service<Request> for FastCgiHttpClientConnector<S>

where S: Service<FastCgiClientRequest, Output = EstablishedClientConnection<IO, FastCgiClientRequest>>, <S as Service<FastCgiClientRequest>>::Error: Into<Box<dyn Error + Sync + Send>>, IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Output = EstablishedClientConnection<IO, FastCgiClientRequest>

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

impl<S, Ingress, C> Service<Ingress> for IoToProxyBridgeIo<S, C>

where S: Service<BridgeIo<Ingress, <C as ConnectorService<ConnectRequest>>::Connection>>, <S as Service<BridgeIo<Ingress, <C as ConnectorService<ConnectRequest>>::Connection>>>::Error: Into<Box<dyn Error + Sync + Send>>, Ingress: Io + ExtensionsRef, C: ConnectorService<ConnectRequest>, <C as ConnectorService<ConnectRequest>>::Connection: Io + Unpin,

type Output = <S as Service<BridgeIo<Ingress, <C as ConnectorService<ConnectRequest>>::Connection>>>::Output

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

impl<S, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for WebSocketRelayService<S>

where S: Service<WebSocketRelayInput>, <S as Service<WebSocketRelayInput>>::Output: Into<WebSocketRelayOutput>, <S as Service<WebSocketRelayInput>>::Error: Into<Box<dyn Error + Sync + Send>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = Infallible

impl<S, Input, BodyConnection> Service<Input> for HttpConnector<S, BodyConnection>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: AuthorityInputExt + ExtensionsRef + HttpVersionInputExt + TargetHttpVersionInputExt + Send + 'static, BodyConnection: Body + Unpin + Send + 'static, <BodyConnection as Body>::Data: Send + 'static, <BodyConnection as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = EstablishedClientConnection<HttpClientService<BodyConnection>, Input>

type Error = ConnectionError

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 + Sync + Send>>, 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 + Sync + Send>>, Input: Send + 'static,

type Error = Infallible

type Output = EstablishedClientConnection<MockSocket, Input>

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

where S: ConnectorService<Input, Connection = Svc>, Svc: Service<Input>, Input: Send + 'static,

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

type Error = ConnectionError

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> Service<Input> for BindBodyToConnector<S>

where S: ConnectorService<Input>, Input: Send + 'static,

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

type Error = ConnectionError

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 ConnectorTargetFromGetSocketname<S>

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

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

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

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 + Sync + Send>>, Input: Send + 'static,

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

type Error = Infallible

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

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

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

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

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

where S: ConnectorService<Input>, Input: AuthorityInputExt + ExtensionsRef + ProtocolInputExt + Send + 'static,

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

type Error = ConnectionError

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

where S: ConnectorService<Input>, Input: Fork + ExtensionsRef + Send + 'static,

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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 UserAgentEmulateHttpConnectModifier<S>

where S: ConnectorService<Input>, Input: ExtensionsRef + HttpVersionInputExt + TargetHttpVersionInputExt + Send + 'static,

type Error = ConnectionError

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

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 Decompression<S, M>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Sync + Send>>, M: ServiceMatcher<Request<ReqBody>, ModifiedInput = Request<ReqBody>>, <M as ServiceMatcher<Request<ReqBody>>>::Service: ServiceMatcher<Response<ResBody>, ModifiedInput = Response<ResBody>, Service = ()>, <<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Error: Into<Box<dyn Error + Sync + Send>>, <M as ServiceMatcher<Request<ReqBody>>>::Error: Into<Box<dyn Error + Sync + Send>>, 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 = Box<dyn Error + Sync + Send>

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 rama::proxy::haproxy::client::HaProxyService<S, P, One>

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

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

type Error = ConnectionError

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

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

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

type Error = ConnectionError

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

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

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

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

impl<S, R, Input> Service<Input> for DnsConnector<S, R>

where S: ConnectorService<Input>, Input: ConnectorTargetInputExt + Send + 'static, R: DnsAddressResolver + Clone,

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

type Error = ConnectionError

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

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Sync + Send>> + Send + Sync + 'static, Input: ConnectorTargetInputExt + ExtensionsRef + Send + 'static, R: DnsAddressResolver + Clone, P: DnsIpPicker,

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

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

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 + Sync + Send>>, Req: Send + 'static, ResBody: Send + Sync + 'static,

type Output = Response<OptionalBody<ResBody>>

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

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 + Sync + Send>>, R: IntoResponse + Send + 'static,

type Output = Response

type Error = Infallible

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, 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 + Sync + Send>>, 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 + Sync + Send>

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 GrpcWebService<S>

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

type Output = Response

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

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 RequestDecompression<S>

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

type Output = Response

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

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

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

type Output = Response<DeadlineBody<ResBody>>

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 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 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> 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 + Sync + Send>>,

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

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

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

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

type Output = Response

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

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

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

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

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

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

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

type Output = Response

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

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

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

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

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

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

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

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

type Error = <S as Service<Request<DeadlineBody<ReqBody>>>>::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 UserAgentEmulateHttpRequestModifier<S>

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

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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 + Sync + Send>>, Body: Send + 'static,

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

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

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, T, ReqBody, ResBody> Service<Request<ReqBody>> for Csrf<S, T>

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

type Output = Response<ResBody>

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

impl<S, T> Service<BridgeIo<S, T>> for IoForwardService

where S: Io + Unpin, T: Io + Unpin,

type Output = IoForwardOutcome

type Error = IoForwardError

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 + Sync + Send>>, W: ResponseWriter, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Response

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

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

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

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

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

impl<S> Service<FastCgiRequest> for FastCgiHttpService<S>

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

type Output = FastCgiResponse

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

impl<S> Service<S> for DiscardService

where S: Io + 'static,

type Output = u64

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

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

where S: Io + 'static,

type Output = u64

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

impl<S> Service<Uri> for PacScriptCache<S>

where S: Service<Uri, Output = PacScript>, <S as Service<Uri>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = PacScript

type Error = OpaqueError

impl<State, L, O, E> Service<Request> for Router<State, L, O, E>

where O: Send + 'static, E: Send + From<RouterError> + 'static, L: Send + Sync + 'static, State: Send + Sync + Clone + 'static,

type Output = O

type Error = E

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: Io + Unpin + ExtensionsRef, Output: Send + 'static, S: Service<SniRequest<Stream>, Output = Output>, <S as Service<SniRequest<Stream>>>::Error: Into<Box<dyn Error + Sync + Send>>, F: Service<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, Stream>, Output = Output>, <F as Service<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, Stream>>>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Output

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

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 + Sync + Send>> + Send + 'static,

type Output = Response

type Error = Infallible

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

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

type Output = Response

type Error = Infallible

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

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

type Output = Response

type Error = Infallible

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

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

type Output = Response

type Error = Infallible

impl<T, F, Input, E> Service<Input> for Abortable<T, F>

where Input: ExtensionsRef + 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, F, Input, E> Service<Input> for rama::layer::Timeout<T, F>

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

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

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

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 + Sync + Send>>, P: Policy<Input>, <P as Policy<Input>>::Error: Into<Box<dyn Error + Sync + Send>>, Input: Send + Sync + 'static,

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

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

impl<T, ReqBody, ResBody> Service<Request<ReqBody>> for TowerHttpServiceAdapter<T>

where T: Service<Request<HyperiumBody<ReqBody>>, Response = Response<ResBody>> + Clone + Send + Sync + 'static, <T as Service<Request<HyperiumBody<ReqBody>>>>::Error: Error + Send + Sync + 'static, <T as Service<Request<HyperiumBody<ReqBody>>>>::Future: Send, ReqBody: Body + Send + 'static, ResBody: Body + Send + 'static,

type Output = Response<RamaBody<ResBody>>

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

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 + Extension + 'static, <T as FromStr>::Err: Into<Box<dyn Error + Sync + Send>> + Send + Sync + 'static, C: FromIterator<T> + Send + Sync + Clone + Debug + Extension + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Sync + Send>> + Send + Sync + 'static,

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

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

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

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

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

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

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

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

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

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