Trait Response

pub trait Response {
    type Buf: Buf;
    type Body: BufStream<Item = Self::Buf, Error = Error>;

    // Required method
    fn into_http<S: Serializer>(
        self,
        context: &Context<'_, S>,
    ) -> Result<Response<Self::Body>, Error>;
}

Types that can be returned from resources as responses to HTTP requests.

Implementations of Response are responsible for encoding the value using the appropriate content type. The content type may be specific to the type in question, for example serde_json::Value implies a content type of application/json.

Alternatively, the provided context may be used to encode the response in most suitable content-type based on the request context. The content-type is picked using the following factors:

• The HTTP request’s Accept header value (not yet implemented).
• Any content type specified by the resource using annotations.
• Serialization formats that the application made available to the resource.

Implementations of Response are able to asynchronously stream the response body if needed. This is done by setting the HTTP response body to a BufStream type that supports streaming.

Required Associated Types

type Buf: Buf

Data chunk type.

type Body: BufStream<Item = Self::Buf, Error = Error>

The HTTP response body type.

Required Methods

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

Convert the value into a response future

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 Response for &'static str

type Buf = Cursor<&'static [u8]>

type Body = Map<&'static str>

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

impl Response for Value

type Buf = <<Value as Response>::Body as BufStream>::Item

type Body = Map<Bytes>

fn into_http<S>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

where S: Serializer,

impl Response for String

type Buf = Cursor<Vec<u8>>

type Body = Map<String>

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

impl Response for File

type Buf = Cursor<BytesMut>

type Body = Map<File>

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

impl<A, B> Response for Either<A, B>

where A: Response, B: Response,

type Buf = <<Either<A, B> as Response>::Body as BufStream>::Item

type Body = Either2<<A as Response>::Body, <B as Response>::Body>

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

impl<R, E> Response for Result<R, E>

where R: Response, E: Into<Error>,

type Buf = <R as Response>::Buf

type Body = <R as Response>::Body

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

impl<T> Response for Vec<T>

where T: Serialize,

type Buf = <SerdeResponse<Vec<T>> as Response>::Buf

type Body = <SerdeResponse<Vec<T>> as Response>::Body

fn into_http<S>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

where S: Serializer,

impl<T> Response for Response<T>

where T: BufStream,

type Buf = <T as BufStream>::Item

type Body = Map<T>

fn into_http<S: Serializer>( self, _: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

impl<T: Response> Response for Option<T>

type Buf = <T as Response>::Buf

type Body = <T as Response>::Body

fn into_http<S: Serializer>( self, context: &Context<'_, S>, ) -> Result<Response<Self::Body>, Error>

Implementors

impl<T> Response for SerdeResponse<T>

where T: Serialize,

type Buf = <<SerdeResponse<T> as Response>::Body as BufStream>::Item

type Body = Map<Bytes>