Trait Service

pub trait Service<Req = ()> {
    type Response;
    type Error;

    // Required method
    fn call(
        &self,
        req: Req,
    ) -> impl Future<Output = Result<Self::Response, Self::Error>>;
}

Trait for simulate Fn<(&Self, Arg)> -> impl Future<Output = Result<T, E>> + '_. The function call come from stateful type that can be referenced within returned opaque future.

Required Associated Types

type Response

The Ok part of output future.

type Error

The Err part of output future.

Required Methods

fn call( &self, req: Req, ) -> impl Future<Output = Result<Self::Response, Self::Error>>

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<'r, C, B> Service<WebContext<'r, C, B>> for Infallible

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, _: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for EncodingError

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, req: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for MultipartError

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for HandshakeError

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Error

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Box<dyn Error + Send + Sync>

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for FromUtf8Error

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Error

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for TooManyRequests

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Error

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Error

type Response = Response<ResponseBody>

type Error = Infallible

async fn call( &self, ctx: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

impl<Arg, R> Service<Arg> for MethodNotAllowedBuilder<R>

where R: Service<Arg>,

type Response = MethodNotAllowedService<<R as Service<Arg>>::Response>

type Error = <R as Service<Arg>>::Error

async fn call( &self, _: Arg, ) -> Result<<MethodNotAllowedBuilder<R> as Service<Arg>>::Response, <MethodNotAllowedBuilder<R> as Service<Arg>>::Error>

impl<Arg, S, E> Service<Arg> for RouteObject<Arg, S, E>

type Response = S

type Error = E

async fn call( &self, arg: Arg, ) -> Result<<RouteObject<Arg, S, E> as Service<Arg>>::Response, <RouteObject<Arg, S, E> as Service<Arg>>::Error>

impl<CF, Fut, C, CErr, S, E> Service<Result<S, E>> for ContextBuilder<CF>

where CF: Fn() -> Fut, Fut: Future<Output = Result<C, CErr>>, C: 'static, CErr: Debug + 'static, E: Debug + 'static,

type Response = ContextService<C, S>

type Error = Box<dyn Debug>

async fn call( &self, res: Result<S, E>, ) -> Result<<ContextBuilder<CF> as Service<Result<S, E>>>::Response, <ContextBuilder<CF> as Service<Result<S, E>>>::Error>

impl<F, C> Service<TcpStream> for Dispatcher<F, C>

where F: for<'h, 'b> AsyncFn(Request<'h, C>, Response<'h>) -> Response<'h, 3>,

type Response = ()

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

async fn call( &self, stream: TcpStream, ) -> Result<<Dispatcher<F, C> as Service<TcpStream>>::Response, <Dispatcher<F, C> as Service<TcpStream>>::Error>

impl<F, Req, T, O> Service<Req> for HandlerService<F, T, ServiceMark>

where T: FromRequest<'static, Req>, F: AsyncFn2<T, Output = O> + for<'a> AsyncFn2<<T as FromRequest<'static, Req>>::Type<'a>>, O: Responder<Req>, <T as FromRequest<'static, Req>>::Error: From<<O as Responder<Req>>::Error>,

type Response = <O as Responder<Req>>::Response

type Error = <T as FromRequest<'static, Req>>::Error

async fn call( &self, req: Req, ) -> Result<<HandlerService<F, T, ServiceMark> as Service<Req>>::Response, <HandlerService<F, T, ServiceMark> as Service<Req>>::Error>

impl<F, T> Service for HandlerService<F, T, BuilderMark>

where F: Clone,

type Response = HandlerService<F, T, ServiceMark>

type Error = Infallible

async fn call( &self, _: (), ) -> Result<<HandlerService<F, T, BuilderMark> as Service>::Response, <HandlerService<F, T, BuilderMark> as Service>::Error>

impl<FA, S, E, const HEADER_LIMIT: usize, const READ_BUF_LIMIT: usize, const WRITE_BUF_LIMIT: usize> Service<Result<S, E>> for HttpServiceBuilder<Http, Stream, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT>

where FA: Service, <FA as Service>::Error: Debug + 'static, E: Debug + 'static,

type Response = HttpService<Stream, S, RequestBody, <FA as Service>::Response, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT>

type Error = Box<dyn Debug>

async fn call( &self, res: Result<S, E>, ) -> Result<<HttpServiceBuilder<Http, Stream, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT> as Service<Result<S, E>>>::Response, <HttpServiceBuilder<Http, Stream, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT> as Service<Result<S, E>>>::Error>

impl<I, Req> Service<Req> for Box<I>

where I: ServiceObject<Req> + ?Sized,

type Response = <I as ServiceObject<Req>>::Response

type Error = <I as ServiceObject<Req>>::Error

async fn call( &self, req: Req, ) -> Result<<Box<I> as Service<Req>>::Response, <Box<I> as Service<Req>>::Error>

impl<Obj, Arg> Service<Arg> for Router<Obj>

where Obj: Service<Arg>, Arg: Clone,

type Response = RouterService<<Obj as Service<Arg>>::Response>

type Error = <Obj as Service<Arg>>::Error

async fn call( &self, arg: Arg, ) -> Result<<Router<Obj> as Service<Arg>>::Response, <Router<Obj> as Service<Arg>>::Error>

impl<R, N, Req, E, const M: usize> Service<Req> for RouteService<R, N, M>

where R: Service<Req, Error = E>, N: Service<Req, Response = <R as Service<Req>>::Response, Error = RouterError<E>>, Req: BorrowReq<Method>,

type Response = <R as Service<Req>>::Response

type Error = RouterError<E>

async fn call( &self, req: Req, ) -> Result<<RouteService<R, N, M> as Service<Req>>::Response, <RouteService<R, N, M> as Service<Req>>::Error>

impl<R, Req> Service<Req> for MethodNotAllowedService<R>

where R: Service<Req>,

type Response = <R as Service<Req>>::Response

type Error = RouterError<<R as Service<Req>>::Error>

async fn call( &self, _: Req, ) -> Result<<MethodNotAllowedService<R> as Service<Req>>::Response, <MethodNotAllowedService<R> as Service<Req>>::Error>

impl<S, Arg> Service<Arg> for RouterMapErr<S>

where S: Service<Arg>,

type Response = MapErrService<<S as Service<Arg>>::Response>

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

async fn call( &self, arg: Arg, ) -> Result<<RouterMapErr<S> as Service<Arg>>::Response, <RouterMapErr<S> as Service<Arg>>::Error>

impl<S, E> Service<Result<S, E>> for H3ServiceBuilder

type Response = H3Service<S>

type Error = E

async fn call( &self, res: Result<S, E>, ) -> Result<<H3ServiceBuilder as Service<Result<S, E>>>::Response, <H3ServiceBuilder as Service<Result<S, E>>>::Error>

impl<S, E> Service<Result<S, E>> for CatchUnwind

type Response = CatchUnwindService<S>

type Error = E

async fn call( &self, arg: Result<S, E>, ) -> Result<<CatchUnwind as Service<Result<S, E>>>::Response, <CatchUnwind as Service<Result<S, E>>>::Error>

impl<S, E> Service<Result<S, E>> for Logger

type Response = LoggerService<S>

type Error = E

async fn call( &self, res: Result<S, E>, ) -> Result<<Logger as Service<Result<S, E>>>::Response, <Logger as Service<Result<S, E>>>::Error>

impl<S, E> Service<Result<S, E>> for SocketConfig

type Response = SocketConfigService<S>

type Error = E

async fn call( &self, res: Result<S, E>, ) -> Result<<SocketConfig as Service<Result<S, E>>>::Response, <SocketConfig as Service<Result<S, E>>>::Error>

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

where S: Service<Req> + ?Sized,

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

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

async fn call( &self, req: Req, ) -> Result<<Arc<S> as Service<Req>>::Response, <Arc<S> as Service<Req>>::Error>

impl<S, Req> Service<Req> for Pin<S>

where S: Deref, <S as Deref>::Target: Service<Req>,

type Response = <<S as Deref>::Target as Service<Req>>::Response

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

async fn call( &self, req: Req, ) -> Result<<Pin<S> as Service<Req>>::Response, <Pin<S> as Service<Req>>::Error>

impl<S, ResB, BE> Service<(QuicStream, SocketAddr)> for H3Service<S>

where S: Service<Request<RequestExt<RequestBody>>, Response = Response<ResB>>, <S as Service<Request<RequestExt<RequestBody>>>>::Error: Debug, ResB: Stream<Item = Result<Bytes, BE>>, BE: Debug,

type Response = ()

type Error = HttpServiceError<<S as Service<Request<RequestExt<RequestBody>>>>::Error, BE>

async fn call( &self, __arg1: (QuicStream, SocketAddr), ) -> Result<<H3Service<S> as Service<(QuicStream, SocketAddr)>>::Response, <H3Service<S> as Service<(QuicStream, SocketAddr)>>::Error>

impl<St, FA, S, E, const HEADER_LIMIT: usize, const READ_BUF_LIMIT: usize, const WRITE_BUF_LIMIT: usize> Service<Result<S, E>> for HttpServiceBuilder<Http1, St, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT>

where FA: Service, <FA as Service>::Error: Debug + 'static, E: Debug + 'static,

type Response = HttpService<St, S, RequestBody, <FA as Service>::Response, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT>

type Error = Box<dyn Debug>

async fn call( &self, res: Result<S, E>, ) -> Result<<HttpServiceBuilder<Http1, St, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT> as Service<Result<S, E>>>::Response, <HttpServiceBuilder<Http1, St, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT> as Service<Result<S, E>>>::Error>

impl<St, FA, S, E, const HEADER_LIMIT: usize, const READ_BUF_LIMIT: usize, const WRITE_BUF_LIMIT: usize> Service<Result<S, E>> for HttpServiceBuilder<Http2, St, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT>

where FA: Service, <FA as Service>::Error: Debug + 'static, E: Debug + 'static,

type Response = HttpService<St, S, RequestBody, <FA as Service>::Response, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT>

type Error = Box<dyn Debug>

async fn call( &self, res: Result<S, E>, ) -> Result<<HttpServiceBuilder<Http2, St, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT> as Service<Result<S, E>>>::Response, <HttpServiceBuilder<Http2, St, FA, HEADER_LIMIT, READ_BUF_LIMIT, WRITE_BUF_LIMIT> as Service<Result<S, E>>>::Error>

impl<T, S, E> Service<Result<S, E>> for Option<T>

where T: Service<Result<S, E>, Error = E>,

type Response = Pipeline<S, <T as Service<Result<S, E>>>::Response>

type Error = <T as Service<Result<S, E>>>::Error

async fn call( &self, res: Result<S, E>, ) -> Result<<Option<T> as Service<Result<S, E>>>::Response, <Option<T> as Service<Result<S, E>>>::Error>

Implementors

impl Service for Redirect

type Response = Redirect

type Error = Infallible

impl<'r, C> Service<WebContext<'r, C>> for xitca_web::error::Error

where C: 'static,

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for ParseError

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for BodyOverFlow

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for ErrorStatus

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for ExtensionNotFound

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for HeaderNotFound

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for InvalidHeaderValue

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for MatchError

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for MethodNotAllowed

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for ThreadJoinError

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for Redirect

type Response = Response<ResponseBody>

type Error = Error

impl<'r, C, B> Service<WebContext<'r, C, B>> for ToStrError

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Service<WebContext<'r, C, B>> for StatusCode

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B, T> Service<WebContext<'r, C, B>> for Html<T>

where T: Clone + Into<ResponseBody>,

type Response = Response<ResponseBody>

type Error = Error

impl<'r, C, B, T> Service<WebContext<'r, C, B>> for Json<T>

where T: Serialize + Clone,

type Response = Response<ResponseBody>

type Error = Error

impl<'r, C, B, T> Service<WebContext<'r, C, B>> for Text<T>

where T: Into<ResponseBody> + Clone,

type Response = Response<ResponseBody>

type Error = Error

impl<'r, C, ReqB, S, ResB> Service<WebContext<'r, C, ReqB>> for TowerCompatService<S>

where S: Service<Request<CompatReqBody<RequestExt<ReqB>, C>>, Response = Response<ResB>>, ResB: Body, C: Clone + 'static, ReqB: Default,

type Response = Response<CompatResBody<ResB>>

type Error = <S as Service<Request<CompatReqBody<RequestExt<ReqB>, C>>>>::Error

impl<'r, S, C, B, Res, Err> Service<WebContext<'r, C, B>> for LimitService<S>

where B: BodyStream + Default, S: for<'r2> Service<WebContext<'r2, C, LimitBody<B>>, Response = Res, Error = Err>,

type Response = Res

type Error = Err

impl<Arg> Service<Arg> for xitca_web::middleware::CatchUnwind

where CatchUnwind: Service<Arg>,

type Response = CatchUnwindService<<CatchUnwind as Service<Arg>>::Response>

type Error = <CatchUnwind as Service<Arg>>::Error

impl<Arg> Service<Arg> for xitca_web::middleware::Logger

where Logger: Service<Arg>,

type Response = <Logger as Service<Arg>>::Response

type Error = <Logger as Service<Arg>>::Error

impl<Arg, R, N, const M: usize> Service<Arg> for Route<R, N, M>

where R: Service<Arg>, N: Service<Arg, Error = <R as Service<Arg>>::Error>, Arg: Clone,

type Response = RouteService<<R as Service<Arg>>::Response, <N as Service<Arg>>::Response, M>

type Error = <R as Service<Arg>>::Error

impl<F> Service for ServeDir<F>

where F: AsyncFs + Clone,

type Response = ServeDirService<F>

type Error = Infallible

impl<F, Req, Res, Err> Service<Req> for FnService<F>

where F: AsyncFn(Req) -> Result<Res, Err>,

type Response = Res

type Error = Err

impl<F, S, E> Service<Result<S, E>> for SyncMiddleware<F>

where F: Clone,

type Response = SyncService<F, S>

type Error = E

impl<F, S, Req> Service<Req> for xitca_web::service::pipeline::PipelineE<F, S>

where F: Service<Req>, S: Service<Req, Response = <F as Service<Req>>::Response, Error = <F as Service<Req>>::Error>,

type Response = <F as Service<Req>>::Response

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

impl<F, T, Arg> Service<Arg> for xitca_web::service::pipeline::PipelineT<F, T, BuildEnclosed>

where F: Service<Arg>, T: Service<Result<<F as Service<Arg>>::Response, <F as Service<Arg>>::Error>>,

type Response = <T as Service<Result<<F as Service<Arg>>::Response, <F as Service<Arg>>::Error>>>::Response

type Error = <T as Service<Result<<F as Service<Arg>>::Response, <F as Service<Arg>>::Error>>>::Error

impl<L, S, E> Service<Result<S, E>> for xitca_web::middleware::tower_http_compat::TowerHttpCompat<L>

where L: Layer<CompatLayer<S>>,

type Response = TowerCompatService<<L as Layer<CompatLayer<S>>>::Service>

type Error = E

impl<M, S, E> Service<Result<S, E>> for TypeEraser<M>

type Response = EraserService<M, S>

type Error = E

impl<R, Arg> Service<Arg> for App<R>

where R: Service<Arg>,

type Response = <R as Service<Arg>>::Response

type Error = <R as Service<Arg>>::Error

impl<R, Arg, C> Service<Arg> for App<R, Box<dyn Fn() -> Pin<Box<dyn Future<Output = Result<C, Box<dyn Debug>>>>> + Send + Sync>>

where R: Service<Arg>,

type Response = NestAppService<C, <R as Service<Arg>>::Response>

type Error = <R as Service<Arg>>::Error

impl<S> Service for xitca_web::service::tower_http_compat::TowerHttpCompat<S>

where S: Clone,

type Response = TowerCompatService<S>

type Error = Infallible

impl<S, E> Service<Result<S, E>> for Compress

type Response = CompressService<S>

type Error = E

impl<S, E> Service<Result<S, E>> for Decompress

type Response = DecompressService<S>

type Error = E

impl<S, E> Service<Result<S, E>> for Limit

type Response = LimitService<S>

type Error = E

impl<S, E> Service<Result<S, E>> for RateLimit

type Response = RateLimitService<S>

type Error = E

impl<S, E> Service<Result<S, E>> for Group<S, E>

type Response = S

type Error = E

impl<S, E> Service<Result<S, E>> for UncheckedReady

type Response = UncheckedReadyService<S>

type Error = E

impl<S, E> Service<Result<S, E>> for WebContext

type Response = WebContextService<S>

type Error = E

impl<S, E, F> Service<Result<S, E>> for AsyncFn<F>

where F: Clone,

type Response = Pipeline<S, F, AsyncFn>

type Error = E

impl<S, Req, F, Err> Service<Req> for xitca_web::service::pipeline::PipelineT<S, F, MapErr>

where S: Service<Req>, F: Fn(<S as Service<Req>>::Error) -> Err,

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

type Error = Err

impl<S, Req, F, Res> Service<Req> for xitca_web::service::pipeline::PipelineT<S, F, Map>

where S: Service<Req>, F: Fn(<S as Service<Req>>::Response) -> Res,

type Response = Res

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

impl<S, Req, F, Res, Err> Service<Req> for xitca_web::service::pipeline::PipelineT<S, F, AsyncFn>

where F: AsyncFn(&S, Req) -> Result<Res, Err>,

type Response = Res

type Error = Err

impl<S, Req, S1> Service<Req> for xitca_web::service::pipeline::PipelineT<S, S1, AndThen>

where S: Service<Req>, S1: Service<<S as Service<Req>>::Response, Error = <S as Service<Req>>::Error>,

type Response = <S1 as Service<<S as Service<Req>>::Response>>::Response

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

impl<SF, Arg, SF1> Service<Arg> for xitca_web::service::pipeline::PipelineT<SF, SF1, BuildAndThen>

where SF: Service<Arg>, Arg: Clone, SF1: Service<Arg>, <SF1 as Service<Arg>>::Error: From<<SF as Service<Arg>>::Error>,

type Response = Pipeline<<SF as Service<Arg>>::Response, <SF1 as Service<Arg>>::Response, AndThen>

type Error = <SF1 as Service<Arg>>::Error

impl<T> Service for Html<T>

where T: Clone,

type Response = Html<T>

type Error = Infallible

impl<T> Service for Json<T>

where T: Clone,

type Response = Json<T>

type Error = Infallible

impl<T> Service for Text<T>

where T: Clone,

type Response = Text<T>

type Error = Infallible

impl<T, S, E> Service<Result<S, E>> for Extension<T>

where T: Clone,

type Response = ExtensionService<S, T>

type Error = E