Type Alias Response

Help

pub type Response = Response<Body>;

Expand description

Response type into which types implementing the Reply trait are convertable.

Aliased Type§

struct Response { /* private fields */ }

Implementations

Source §

impl<T> Response<T>

Source

pub fn new(body: T) -> Response<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(), "hello world");

Source

pub fn from_parts(parts: Parts, body: T) -> Response<T>

Creates a new Response with the given head and body

§Examples

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

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

assert_eq!(response.status(), StatusCode::BAD_REQUEST);
assert_eq!(*response.body(), "hello world");

Source

pub fn status(&self) -> StatusCode

Returns the StatusCode.

§Examples

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

Source

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

Returns a mutable reference to the associated StatusCode.

§Examples

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

Source

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

Source

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

Source

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

§Examples

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

Source

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

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

Source

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

Source

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(), Some(&"hello"));

Source

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

§Examples

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

Source

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

Returns a mutable reference to the associated HTTP body.

§Examples

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

Source

pub fn into_body(self) -> T

Consumes the response, returning just the body.

§Examples

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

Source

pub fn into_parts(self) -> (Parts, T)

Consumes the response returning the head and body parts.

§Examples

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

Source

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

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<&[u8]> = response.map(|b| {
  assert_eq!(b, "some string");
  b.as_bytes()
});
assert_eq!(mapped_response.body(), &"some string".as_bytes());