Trait xitca_web::handler::Responder

pub trait Responder<Req> {
    type Response;
    type Error;

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

    // Provided method
    fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>
       where Self: Sized { ... }
}

Make Response with ownership of Req. The Output type is what returns from handler_service function.

Required Associated Types

type Response

type Error

Required Methods

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

generate response from given request.

Provided Methods

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

where Self: Sized,

map response type and mutate it’s state. default to pass through without any modification.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'r, C, B> Responder<WebContext<'r, C, B>> for &'static str

type Response = Response<ResponseBody>

type Error = Error<C>

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for (HeaderName, HeaderValue)

type Response = Response<ResponseBody>

type Error = Error<C>

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Cow<'static, str>

type Response = Response<ResponseBody>

type Error = Error<C>

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Value

type Response = Response<ResponseBody>

type Error = Error<C>

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Box<str>

type Response = Response<ResponseBody>

type Error = Error<C>

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for String

type Response = Response<ResponseBody>

type Error = Error<C>

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Vec<u8>

type Response = Response<ResponseBody>

type Error = Infallible

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

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

impl<'r, C, B, T, Res, Err, E> Responder<WebContext<'r, C, B>> for Result<T, E>

where T: for<'r2> Responder<WebContext<'r2, C, B>, Response = Res, Error = Err>, Error<C>: From<E> + From<Err>,

type Response = Res

type Error = Error<C>

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

impl<Req, A> Responder<Req> for (A,)

where A: Responder<Req>,

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

type Error = <A as Responder<Req>>::Error

async fn respond( self, req: Req ) -> Result<<(A,) as Responder<Req>>::Response, <(A,) as Responder<Req>>::Error>

fn map( self, res: <(A,) as Responder<Req>>::Response ) -> Result<<(A,) as Responder<Req>>::Response, <(A,) as Responder<Req>>::Error>

impl<Req, A, B> Responder<Req> for (A, B)

where A: Responder<Req>, B: Responder<Req, Response = <A as Responder<Req>>::Response>, <A as Responder<Req>>::Error: From<<B as Responder<Req>>::Error>,

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

type Error = <A as Responder<Req>>::Error

async fn respond( self, req: Req ) -> Result<<(A, B) as Responder<Req>>::Response, <(A, B) as Responder<Req>>::Error>

fn map( self, res: <(A, B) as Responder<Req>>::Response ) -> Result<<(A, B) as Responder<Req>>::Response, <(A, B) as Responder<Req>>::Error>

impl<Req, A, B, C> Responder<Req> for (A, B, C)

where A: Responder<Req>, B: Responder<Req, Response = <A as Responder<Req>>::Response>, <A as Responder<Req>>::Error: From<<B as Responder<Req>>::Error> + From<<C as Responder<Req>>::Error>, C: Responder<Req, Response = <A as Responder<Req>>::Response>,

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

type Error = <A as Responder<Req>>::Error

async fn respond( self, req: Req ) -> Result<<(A, B, C) as Responder<Req>>::Response, <(A, B, C) as Responder<Req>>::Error>

fn map( self, res: <(A, B, C) as Responder<Req>>::Response ) -> Result<<(A, B, C) as Responder<Req>>::Response, <(A, B, C) as Responder<Req>>::Error>

impl<Req, A, B, C, D> Responder<Req> for (A, B, C, D)

where A: Responder<Req>, B: Responder<Req, Response = <A as Responder<Req>>::Response>, <A as Responder<Req>>::Error: From<<B as Responder<Req>>::Error> + From<<C as Responder<Req>>::Error> + From<<D as Responder<Req>>::Error>, C: Responder<Req, Response = <A as Responder<Req>>::Response>, D: Responder<Req, Response = <A as Responder<Req>>::Response>,

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

type Error = <A as Responder<Req>>::Error

async fn respond( self, req: Req ) -> Result<<(A, B, C, D) as Responder<Req>>::Response, <(A, B, C, D) as Responder<Req>>::Error>

fn map( self, res: <(A, B, C, D) as Responder<Req>>::Response ) -> Result<<(A, B, C, D) as Responder<Req>>::Response, <(A, B, C, D) as Responder<Req>>::Error>

impl<Req, A, B, C, D, E> Responder<Req> for (A, B, C, D, E)

where A: Responder<Req>, B: Responder<Req, Response = <A as Responder<Req>>::Response>, <A as Responder<Req>>::Error: From<<B as Responder<Req>>::Error> + From<<C as Responder<Req>>::Error> + From<<D as Responder<Req>>::Error> + From<<E as Responder<Req>>::Error>, C: Responder<Req, Response = <A as Responder<Req>>::Response>, D: Responder<Req, Response = <A as Responder<Req>>::Response>, E: Responder<Req, Response = <A as Responder<Req>>::Response>,

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

type Error = <A as Responder<Req>>::Error

async fn respond( self, req: Req ) -> Result<<(A, B, C, D, E) as Responder<Req>>::Response, <(A, B, C, D, E) as Responder<Req>>::Error>

fn map( self, res: <(A, B, C, D, E) as Responder<Req>>::Response ) -> Result<<(A, B, C, D, E) as Responder<Req>>::Response, <(A, B, C, D, E) as Responder<Req>>::Error>

impl<Req, A, B, C, D, E, F> Responder<Req> for (A, B, C, D, E, F)

where A: Responder<Req>, B: Responder<Req, Response = <A as Responder<Req>>::Response>, <A as Responder<Req>>::Error: From<<B as Responder<Req>>::Error> + From<<C as Responder<Req>>::Error> + From<<D as Responder<Req>>::Error> + From<<E as Responder<Req>>::Error> + From<<F as Responder<Req>>::Error>, C: Responder<Req, Response = <A as Responder<Req>>::Response>, D: Responder<Req, Response = <A as Responder<Req>>::Response>, E: Responder<Req, Response = <A as Responder<Req>>::Response>, F: Responder<Req, Response = <A as Responder<Req>>::Response>,

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

type Error = <A as Responder<Req>>::Error

async fn respond( self, req: Req ) -> Result<<(A, B, C, D, E, F) as Responder<Req>>::Response, <(A, B, C, D, E, F) as Responder<Req>>::Error>

fn map( self, res: <(A, B, C, D, E, F) as Responder<Req>>::Response ) -> Result<<(A, B, C, D, E, F) as Responder<Req>>::Response, <(A, B, C, D, E, F) as Responder<Req>>::Error>

Implementors

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Bytes

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B> Responder<WebContext<'r, C, B>> for BytesMut

type Response = Response<ResponseBody>

type Error = Infallible

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

type Response = Response<ResponseBody>

type Error = Error<C>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for HeaderMap

type Response = Response<ResponseBody>

type Error = Error<C>

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

type Response = Response<ResponseBody>

type Error = Error<C>

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

type Response = Response<ResponseBody>

type Error = Error<C>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for WebSocket<B>

where B: BodyStream + 'static,

type Response = Response<ResponseBody>

type Error = Infallible

impl<'r, C, B, K> Responder<WebContext<'r, C, B>> for CookieJar<K>

type Response = Response<ResponseBody>

type Error = Error<C>

impl<'r, C, B, ResB> Responder<WebContext<'r, C, B>> for WebResponse<ResB>

type Response = Response<ResB>

type Error = Error<C>

impl<'r, C, B, T> Responder<WebContext<'r, C, B>> for Form<T>

where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error<C>

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

where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error<C>

impl<'r, C, T> Responder<WebContext<'r, C>> for Html<T>

where T: Into<ResponseBody>,

type Response = Response<ResponseBody>

type Error = Infallible

impl<R, F, S> Responder<R> for Pipeline<F, S>

where F: Responder<R>, S: Responder<R, Response = <F as Responder<R>>::Response>, <F as Responder<R>>::Error: From<<S as Responder<R>>::Error>,

type Response = <F as Responder<R>>::Response

type Error = <F as Responder<R>>::Error