Trait rama::Service

pub trait Service<S, Request>: Sized + Send + Sync + 'static {
    type Response: Send + 'static;
    type Error: Send + Sync + 'static;

    // Required method
    fn serve(
        &self,
        ctx: Context<S>,
        req: Request,
    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send;

    // Provided method
    fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error> { ... }
}

A Service that produces rama services, to serve requests with, be it transport layer requests or application layer requests.

Required Associated Types

type Response: Send + 'static

The type of response returned by the service.

type Error: Send + Sync + 'static

The type of error returned by the service.

Required Methods

fn serve( &self, ctx: Context<S>, req: Request, ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send

Serve a response or error for the given request, using the given context.

Provided Methods

fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>

Box this service to allow for dynamic dispatch.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<S, Request> Service<S, Request> for ()

where S: Send + Sync + 'static, Request: Send + 'static,

type Response = Request

type Error = Infallible

async fn serve( &self, _ctx: Context<S>, req: Request, ) -> Result<<() as Service<S, Request>>::Response, <() as Service<S, Request>>::Error>

impl<S, State, Request> Service<State, Request> for Box<S>

where S: Service<State, Request>,

type Response = <S as Service<State, Request>>::Response

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

fn serve( &self, ctx: Context<State>, req: Request, ) -> impl Future<Output = Result<<Box<S> as Service<State, Request>>::Response, <Box<S> as Service<State, Request>>::Error>> + Send

impl<S, State, Request> Service<State, Request> for Arc<S>

where S: Service<State, Request>,

type Response = <S as Service<State, Request>>::Response

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

fn serve( &self, ctx: Context<State>, req: Request, ) -> impl Future<Output = Result<<Arc<S> as Service<State, Request>>::Response, <Arc<S> as Service<State, Request>>::Error>> + Send

impl<State, 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, Request, Response, Error> Service<State, Request> for ((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 State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, M_T10: Matcher<State, Request>, T10: Service<State, Request, Response = Response, Error = Error>, M_T11: Matcher<State, Request>, T11: Service<State, Request, Response = Response, Error = Error>, M_T12: Matcher<State, Request>, T12: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((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) as Service<State, Request>>::Response, <((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) as Service<State, Request>>::Error>

impl<State, 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, Request, Response, Error> Service<State, Request> for ((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 State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, M_T10: Matcher<State, Request>, T10: Service<State, Request, Response = Response, Error = Error>, M_T11: Matcher<State, Request>, T11: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((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) as Service<State, Request>>::Response, <((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) as Service<State, Request>>::Error>

impl<State, 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, Request, Response, Error> Service<State, Request> for ((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 State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, M_T10: Matcher<State, Request>, T10: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((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) as Service<State, Request>>::Response, <((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) as Service<State, Request>>::Error>

impl<State, 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, Request, Response, Error> Service<State, Request> for ((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 State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((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) as Service<State, Request>>::Response, <((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) as Service<State, Request>>::Error>

impl<State, 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, Request, Response, Error> Service<State, Request> for ((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 State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((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) as Service<State, Request>>::Response, <((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) as Service<State, Request>>::Error>

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

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

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S) as Service<State, Request>>::Error>

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S)

where State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S) as Service<State, Request>>::Error>

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S)

where State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S) as Service<State, Request>>::Error>

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S)

where State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S) as Service<State, Request>>::Error>

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), S)

where State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), S) as Service<State, Request>>::Error>

impl<State, M_T1, T1, M_T2, T2, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), S)

where State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), S) as Service<State, Request>>::Error>

impl<State, M_T1, T1, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), S)

where State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), S) as Service<State, Request>>::Response, <((M_T1, T1), S) as Service<State, Request>>::Error>

Implementors

impl Service<(), Request<Body>> for rama::cli::service::echo::EchoService

type Response = Response<Body>

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

impl Service<(), Request<Body>> for HttpEchoService

type Response = Response<Body>

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

impl<A, B, C, D, E, F, G, H, I, State, Request, Response> Service<State, Request> for Either9<A, B, C, D, E, F, G, H, I>

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

type Response = Response

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

impl<A, B, C, D, E, F, G, H, State, Request, Response> Service<State, Request> for Either8<A, B, C, D, E, F, G, H>

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

type Response = Response

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

impl<A, B, C, D, E, F, G, State, Request, Response> Service<State, Request> for Either7<A, B, C, D, E, F, G>

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

type Response = Response

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

impl<A, B, C, D, E, F, State, Request, Response> Service<State, Request> for Either6<A, B, C, D, E, F>

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

type Response = Response

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

impl<A, B, C, D, E, State, Request, Response> Service<State, Request> for Either5<A, B, C, D, E>

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

type Response = Response

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

impl<A, B, C, D, State, Request, Response> Service<State, Request> for Either4<A, B, C, D>

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

type Response = Response

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

impl<A, B, C, State, Request, Response> Service<State, Request> for Either3<A, B, C>

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

type Response = Response

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

impl<A, B, State, Request, Response> Service<State, Request> for Either<A, B>

where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

type Response = Response

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

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

where A: Authority<C, L>, C: Credentials + Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, L: 'static, ReqBody: Send + 'static, ResBody: Default + Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

where B: HyperConnServer, State: Send + Sync + 'static, S: Service<State, Request<Body>, Response = Response, Error = Infallible>, Response: IntoResponse + Send + 'static, IO: Stream,

type Response = ()

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

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

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

type Response = <S as Service<State, Request<NewReqBody>>>::Response

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

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

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

type Response = Response<NewResBody>

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

impl<H, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, H>

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

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<Input> Service<(), Input> for TcpEchoService

where Input: Stream + Unpin,

type Response = ()

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

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

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

type Response = <S as Service<State, Request<RetryBody>>>::Response

type Error = RetryError

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

where S: Service<State, Request<ReqBody>, Response = 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, State: Send + Sync + 'static,

type Response = Response<CompressionBody<ResBody>>

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

impl<ReqBody, ResBody, S, State, Auth> Service<State, Request<ReqBody>> for AsyncRequireAuthorization<S, Auth>

where Auth: AsyncAuthorizeRequest<State, ReqBody, ResponseBody = ResBody> + Send + Sync + 'static, S: Service<State, Request<<Auth as AsyncAuthorizeRequest<State, ReqBody>>::RequestBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static, State: Send + Sync + 'static,

type Response = Response<ResBody>

type Error = <S as Service<State, Request<<Auth as AsyncAuthorizeRequest<State, ReqBody>>::RequestBody>>>::Error

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

impl<ReqBody, ResBody, State, S, V> Service<State, Request<ReqBody>> for ValidateRequestHeader<S, V>

where ReqBody: Send + 'static, ResBody: Send + 'static, State: Send + Sync + 'static, V: ValidateRequest<State, ReqBody, ResponseBody = ResBody>, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>,

type Response = Response<ResBody>

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

impl<S, D, P, F, State, Request> Service<State, Request> for ProxyDBService<S, D, P, F>

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

type Response = <S as Service<State, Request>>::Response

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

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

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

type Response = Response<Body>

type Error = Infallible

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

where S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Response: IntoResponse, F: AttributesFactory<State>, State: Send + Sync + 'static, Body: Send + 'static,

type Response = Response<Body>

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

impl<S, F, State, R1, R2> Service<State, R1> for MapRequest<S, F>

where S: Service<State, R2>, F: FnOnce(R1) -> R2 + Clone + Send + Sync + 'static,

type Response = <S as Service<State, R2>>::Response

type Error = <S as Service<State, R2>>::Error

impl<S, F, State, Request> Service<State, Request> for ConsumeErr<S, F>

where S: Service<State, Request>, <S as Service<State, Request>>::Response: Default, F: FnOnce(<S as Service<State, Request>>::Error) + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static,

type Response = <S as Service<State, Request>>::Response

type Error = Infallible

impl<S, F, State, Request, Error> Service<State, Request> for MapErr<S, F>

where S: Service<State, Request>, F: FnOnce(<S as Service<State, Request>>::Error) -> Error + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static, Error: Send + Sync + 'static,

type Response = <S as Service<State, Request>>::Response

type Error = Error

impl<S, F, State, Request, R> Service<State, Request> for ConsumeErr<S, F, StaticResponse<R>>

where S: Service<State, Request>, F: FnOnce(<S as Service<State, Request>>::Error) + Clone + Send + Sync + 'static, R: Into<<S as Service<State, Request>>::Response> + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static,

type Response = <S as Service<State, Request>>::Response

type Error = Infallible

impl<S, F, State, Request, Response> Service<State, Request> for MapResponse<S, F>

where S: Service<State, Request>, F: FnOnce(<S as Service<State, Request>>::Response) -> Response + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static,

type Response = Response

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

impl<S, F, State, Request, Response, Error> Service<State, Request> for MapResult<S, F>

where S: Service<State, Request>, F: FnOnce(Result<<S as Service<State, Request>>::Response, <S as Service<State, Request>>::Error>) -> Result<Response, Error> + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

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

where S: Service<State, Stream>, F: AttributesFactory<State>, State: Send + Sync + 'static, Stream: Stream,

type Response = <S as Service<State, Stream>>::Response

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

impl<S, F, W, State, Request> Service<State, Request> for MapState<S, F>

where S: Service<W, Request>, State: Send + Sync + 'static, W: Send + Sync + 'static, F: FnOnce(Arc<State>) -> Arc<W> + Clone + Send + Sync + 'static, Request: Send + 'static,

type Response = <S as Service<W, Request>>::Response

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

impl<S, H, M, State, Request> Service<State, Request> for HijackService<S, H, M>

where S: Service<State, Request>, H: Service<State, Request>, <H as Service<State, Request>>::Response: Into<<S as Service<State, Request>>::Response>, <H as Service<State, Request>>::Error: Into<<S as Service<State, Request>>::Error>, M: Matcher<State, Request>, State: Send + Sync + 'static, Request: Send + 'static,

type Response = <S as Service<State, Request>>::Response

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

impl<S, H, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, H>

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

type Response = <S as Service<State, Request<Body>>>::Response

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

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

where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Send + 'static, State: Send + Sync + 'static, Request: Send + 'static,

type Response = EstablishedClientConnection<<S as ConnectorService<State, Request>>::Connection, State, Request>

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

impl<S, P, State, Request, T> Service<State, Request> for rama::proxy::haproxy::client::HaProxyService<S, P>

where S: Service<State, Request, Response = EstablishedClientConnection<T, State, Request>>, <S as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Protocol + Send + 'static, State: Send + Sync + 'static, Request: Send + 'static, T: Stream + Unpin,

type Response = EstablishedClientConnection<T, State, Request>

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

impl<S, Request, Response, Error> Service<S, Request> for BoxService<S, Request, Response, Error>

where S: 'static, Request: 'static, Response: Send + 'static, Error: Send + Sync + 'static,

type Response = Response

type Error = Error

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, State, Body> Service<State, Request<Body>> for HttpConnector<S>

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

type Response = EstablishedClientConnection<HttpClientService<Body>, State, Request<Body>>

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

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

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

type Response = Response<Body>

type Error = Infallible

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

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

where S: Service<State, IO>, State: Send + Sync + 'static, IO: Stream,

type Response = <S as Service<State, IO>>::Response

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

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

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

type Response = O

type Error = E

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

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

type Response = <S as Service<State, Request<Limited<ReqBody>>>>::Response

type Error = <S as Service<State, Request<Limited<ReqBody>>>>::Error

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = Response<Body>

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = Response<DecompressionBody<ResBody>>

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = Response<UnsyncBoxBody<D, Box<dyn Error + Send + Sync>>>

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

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

where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, <S as Service<State, Request<ReqBody>>>::Error: Display, State: Send + Sync + 'static, 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 Response = Response<ResponseBody<ResBody, <M as MakeClassifier>::ClassifyEos, OnBodyChunkT, OnEosT, OnFailureT>>

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

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

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

type Response = <S as Service<State, Request>>::Response

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

impl<S, State, Request> Service<State, Request> for HttpProxyConnector<S>

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

type Response = EstablishedClientConnection<<S as ConnectorService<State, Request>>::Connection, State, Request>

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

impl<S, State, Request> Service<State, Request> for ConsumeErr<S, Trace>

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

type Response = <S as Service<State, Request>>::Response

type Error = Infallible

impl<S, State, Request> Service<State, Request> for TraceErr<S>

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

type Response = <S as Service<State, Request>>::Response

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

impl<S, State, Request> Service<State, Request> for OutgoingBytesTrackerService<S>

where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static,

type Response = EstablishedClientConnection<BytesRWTracker<<S as ConnectorService<State, Request>>::Connection>, State, Request>

type Error = <S as ConnectorService<State, Request>>::Error

impl<S, State, Request> Service<State, Request> for rama::tls::boring::client::HttpsConnector<S>

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

this way we do not need a hacky macro… however is there a way to do this without needing to hacK?!?!

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

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

impl<S, State, Request> Service<State, Request> for rama::tls::boring::client::HttpsConnector<S, ConnectorKindSecure>

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

type Response = EstablishedClientConnection<SslStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

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

impl<S, State, Request> Service<State, Request> for rama::tls::boring::client::HttpsConnector<S, ConnectorKindTunnel>

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

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

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

impl<S, State, Request> Service<State, Request> for rama::tls::rustls::client::HttpsConnector<S>

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

this way we do not need a hacky macro… however is there a way to do this without needing to hacK?!?!

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

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

impl<S, State, Request> Service<State, Request> for rama::tls::rustls::client::HttpsConnector<S, ConnectorKindSecure>

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

type Response = EstablishedClientConnection<TlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

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

impl<S, State, Request> Service<State, Request> for rama::tls::rustls::client::HttpsConnector<S, ConnectorKindTunnel>

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

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

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

impl<S, State, Request, R> Service<State, Request> for ConsumeErr<S, Trace, StaticResponse<R>>

where S: Service<State, Request>, <S as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, R: Into<<S as Service<State, Request>>::Response> + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Request: Send + 'static,

type Response = <S as Service<State, Request>>::Response

type Error = Infallible

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, T7, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, State, Body> Service<State, 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<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

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

where S: Send + Sync + 'static, T: Stream + Unpin, C: ConnectorService<S, Request>, <C as ConnectorService<S, Request>>::Connection: Stream + Unpin, <C as ConnectorService<S, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, L: Layer<ForwarderService<<C as ConnectorService<S, Request>>::Connection>> + Send + Sync + 'static, <L as Layer<ForwarderService<<C as ConnectorService<S, Request>>::Connection>>>::Service: Service<S, T, Response = ()>, <<L as Layer<ForwarderService<<C as ConnectorService<S, Request>>::Connection>>>::Service as Service<S, T>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Response = ()

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

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

where State: Send + Sync + 'static,

type Response = Response<Body>

type Error = Infallible

impl<State, Body> Service<State, Request<Body>> for HttpClient

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

type Response = Response<Body>

type Error = OpaqueError

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

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

type Response = Response<Body>

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

impl<State, Body, ResBody> Service<State, Request<Body>> for Redirect<ResBody>

where State: Send + Sync + 'static, Body: Send + 'static, ResBody: Default + Send + 'static,

type Response = Response<ResBody>

type Error = Infallible

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

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

type Response = <S as Service<State, Request<Body>>>::Response

type Error = OpaqueError

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

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

type Response = Response<Body>

type Error = Infallible

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

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

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

type Response = <ServeDir as Service<State, Request<ReqBody>>>::Response

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

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

type Response = Response<Body>

type Error = Infallible

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

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

type Response = Response<ResBody>

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

impl<State, Request, Dns, Connector> Service<State, Request> for TcpConnector<Dns, Connector>

where State: Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, Dns: DnsResolver + Clone, <Dns as DnsResolver>::Error: Into<Box<dyn Error + Send + Sync>>, Connector: TcpStreamConnector + Clone, <Connector as TcpStreamConnector>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Response = EstablishedClientConnection<TcpStream, State, Request>

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

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

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

type Response = O

type Error = E

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

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

type Response = <S as Service<State, Request>>::Response

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

impl<State, Request, S, T, Fut, F> Service<State, Request> for GetExtension<S, T, Fut, F>

where State: Send + Sync + 'static, Request: Send + 'static, S: Service<State, Request>, T: Clone + Send + Sync + 'static, F: FnOnce(T) -> Fut + Clone + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

type Response = <S as Service<State, Request>>::Response

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

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

where State: Send + Sync + 'static, S: Service<State, BytesRWTracker<IO>>, IO: Stream,

type Response = <S as Service<State, BytesRWTracker<IO>>>::Response

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

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

where State: Send + Sync + 'static, S: Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>, <S as Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: Stream + Unpin,

type Response = <S as Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = <S as Service<State, Request<ReqBody>>>::Response

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

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

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

type Response = Response<Body>

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

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

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

type Response = Response<ResBody>

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

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

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

type Response = Response<Body>

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

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, T7, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S, State, Body> Service<State, 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<State, Request<Body>>, Body: Send + 'static, State: Send + Sync + 'static,

type Response = <S as Service<State, Request<Body>>>::Response

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

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

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

type Response = <T as Service<S, Request>>::Response

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

impl<T, P, State, Request> Service<State, Request> for Limit<T, P>

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

type Response = <T as Service<State, Request>>::Response

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

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

where T: Send + Sync + 'static, S: Stream + 'static,

type Response = u64

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

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

where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, SslStream<IO>>,

type Response = <S as Service<T, SslStream<IO>>>::Response

type Error = TlsAcceptorError<<S as Service<T, SslStream<IO>>>::Error>

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

where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>,

type Response = <S as Service<T, TlsStream<IO>>>::Response

type Error = TlsAcceptorError<<S as Service<T, TlsStream<IO>>>::Error>

impl<T, S, IO> Service<T, IO> for rama::tls::rustls::server::TlsAcceptorService<S, TlsClientConfigHandler<()>>

where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>,

type Response = <S as Service<T, TlsStream<IO>>>::Response

type Error = TlsAcceptorError<<S as Service<T, TlsStream<IO>>>::Error>

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

where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>, F: ServerConfigProvider,

type Response = <S as Service<T, TlsStream<IO>>>::Response

type Error = TlsAcceptorError<<S as Service<T, TlsStream<IO>>>::Error>

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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

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

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

type Response = <S as Service<State, Request<Body>>>::Response

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