Struct dyer::Response

pub struct Response {
    pub inner: InnerResponse,
    pub body: Body,
    pub metas: MetaResponse,
    /* private fields */
}

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());

impl Response

pub fn xpath(&mut self, xpath: &str) -> Vec<Node>

Available on crate feature xpath only.

parse the ready response’s body with xpath

the feature xpath must be enabled

let html = r#"<!doctype html>
<html>
    <title>Hello dyer!</title>
    <body> ... </body>
</html>"#;
let body = Body::from(html);
let mut res = Response::new(body);
let title = res.xpath("//title/text()");
assert_eq!(
    title[0]
        .get_content(),
    "Hello dyer!"
);

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

Converts to this type from the input type.

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.

impl Send for Response

Safety: the safety of InnerResponse and MetaResponse is addressed repectively, the body is obviously Send and Sync xpath related dom and context can only be called when Response is successful and step into parse Since we parse the response’s body in main thread, it should be Send and Sync

impl Sync for Response

Safety: the safety of InnerResponse and MetaResponse is addressed repectively, the body is obviously Send and Sync xpath related dom and context can only be called when Response is successful and step into parse Since we parse the response’s body in main thread, it should be Send and Sync