Struct dyer::Response

pub struct Response {
    pub inner: InnerResponse,
    pub body: Body,
    pub metas: MetaResponse,
}

An Wrapper of http::Response

Represents an HTTP response

An HTTP response consists of a head and a potentially optional body. The body component is generic, enabling arbitrary types to represent the HTTP body. For example, the body could be Vec, a Stream of byte chunks, or a value that has been deserialized.

Typically you’ll work with responses on the client side as the result of sending a Request and on the server you’ll be generating a Response to send back to the client.

Fields

inner: InnerResponse

inner parts of Response

body: Body

body

metas: MetaResponse

the metadata of the response

Implementations

impl Response

pub fn builder() -> ResponseBuilder

Creates a new builder-style object to manufacture a Response

This method returns an instance of ResponseBuilder which can be used to create a Response.

Examples

let response = Response::builder()
    .status(200)
    .header("accept", "*/*")
    .body(Body::empty())
    .unwrap();

pub fn new<T>(body: T) -> Response where
    Body: From<T>, 

Creates a new blank Response with the body

The component ports of this response will be set to their default, e.g. the ok status, no headers, etc.

Examples

let response = Response::new("hello world");

assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.body(), &Body::from("hello world"));

pub fn from_parts(
    inner: InnerResponse,
    body: Body,
    meta: MetaResponse
) -> Response

Creates a new Response with the given head and body

Examples

let response = Response::new("hello world");
let (mut inner, body, meta) = response.into_parts();

inner.status = StatusCode::BAD_REQUEST;
let response = Response::from_parts(inner, body, meta);

assert_eq!(response.status(), StatusCode::BAD_REQUEST);

pub fn status(&self) -> StatusCode

Returns the StatusCode.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.status(), StatusCode::OK);

pub fn status_mut(&mut self) -> &mut StatusCode

Returns a mutable reference to the associated StatusCode.

Examples

let mut response = Response::default();
*response.status_mut() = StatusCode::CREATED;
assert_eq!(response.status(), StatusCode::CREATED);

pub fn version(&self) -> Version

Returns a reference to the associated version.

Examples

let response: Response = Response::default();
assert_eq!(response.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut response: Response = Response::default();
*response.version_mut() = Version::HTTP_2;
assert_eq!(response.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap<HeaderValue>

Get a share reference to the header of HeaderMap.

Examples

let response: Response = Response::default();
assert!(response.headers().is_empty());

pub fn headers_mut(&mut self) -> &mut HeaderMap<HeaderValue>

Returns a mutable reference to the associated header field map.

Examples

let mut response: Response = Response::default();
response.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!response.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

Examples

let response: Response = Response::default();
assert!(response.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Examples

let mut response: Response<()> = Response::default();
response.extensions_mut().insert("hello");
assert_eq!(response.extensions().get::<&'static str>(), Some(&"hello"));

pub fn exts(&self) -> &Extensions

Returns a reference to the associated extensions of metadata.

Examples

let response: Response<()> = Response::default();
assert!(response.exts().get::<i32>().is_none());

pub fn exts_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions of metadata.

Examples

let mut response: Response<()> = Response::default();
response.extensions_mut().insert("hello");
assert_eq!(response.exts().get(), Some(&"hello"));

pub fn body(&self) -> &Body

Returns a reference to the associated HTTP body.

Examples

let response: Response = Response::default();
assert!(response.body().is_empty());

pub fn body_mut(&mut self) -> &mut Body

Returns a mutable reference to the associated HTTP body.

Examples

let mut response: Response<String> = Response::default();
response.body_mut() = Body::from("hello world");
assert!(!response.body().is_empty());

pub fn into_body(self) -> Body

Consumes the response, returning just the body.

Examples

let response = Response::new(10);
let body = response.into_body();
assert_eq!(body, Body::from(10));

pub fn into_parts(self) -> (InnerResponse, Body, MetaResponse)

Consumes the response returning the head, metadata and body parts.

Examples

let response: Response = Response::default();
let (parts, body, meta) = response.into_parts();
assert_eq!(parts.status, StatusCode::OK);

pub fn map<F>(self, f: F) -> Response where
    F: FnOnce(Body) -> Body, 

Consumes the response returning a new response with body mapped to the return type of the passed in function.

Examples

let response = Response::builder().body("some string").unwrap();
let mapped_response: Response = response.map(|b| {
  Body::from(b.bytes())
});
assert_eq!(mapped_response.body().bytes(), "some string".as_bytes());

Trait Implementations

impl Default for Response

fn default() -> Response

Returns the “default value” for a type.

impl From<Response> for Poly

fn from(response: Response) -> Self

Performs the conversion.

impl TryInto<Response> for Poly

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.