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

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> Responder<WebContext<'r, C, B>> for &'static str

type Response = Response<ResponseBody>

type Error = Error

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

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

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

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

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

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<(HeaderName, HeaderValue)>

type Response = Response<ResponseBody>

type Error = Error

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: From<E> + From<Err>,

type Response = Res

type Error = Error

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

impl<'r, C, B, const N: usize> Responder<WebContext<'r, C, B>> for [(HeaderName, HeaderValue); N]

type Response = Response<ResponseBody>

type Error = Error

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<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 BoxBody

type Response = Response<ResponseBody>

type Error = Error

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

type Response = Response<ResponseBody>

type Error = Error

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

type Response = Response<ResponseBody>

type Error = Error

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

type Response = Response<ResponseBody>

type Error = Error

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

type Response = Response<ResponseBody>

type Error = Error

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

type Response = Response<ResponseBody>

type Error = Error

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

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

type Response = Response<ResponseBody<ResB>>

type Error = Error

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

type Response = Response<ResB>

type Error = Error

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

where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error

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

where T: Into<ResponseBody>,

type Response = Response<ResponseBody>

type Error = Error

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

where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error

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

where T: Into<ResponseBody>,

type Response = Response<ResponseBody>

type Error = Error

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