Struct http_types::Response [−][src]
pub struct Response { /* fields omitted */ }
Expand description
An HTTP response.
Examples
use http_types::{Response, StatusCode}; let mut res = Response::new(StatusCode::Ok); res.set_body("Hello, Nori!");
Implementations
Create a new response.
Get the status
Get a mutable reference to a header.
Get an HTTP header.
Remove a header.
pub fn insert_header(
&mut self,
name: impl Into<HeaderName>,
values: impl ToHeaderValues
) -> Option<HeaderValues>
pub fn insert_header(
&mut self,
name: impl Into<HeaderName>,
values: impl ToHeaderValues
) -> Option<HeaderValues>
Set an HTTP header.
Examples
use http_types::{Method, Response, StatusCode, Url}; let mut req = Response::new(StatusCode::Ok); req.insert_header("Content-Type", "text/plain");
Append a header to the headers.
Unlike insert
this function will not override the contents of a
header, but insert a header if there aren’t any. Or else append to
the existing list of headers.
Examples
use http_types::{Response, StatusCode}; let mut res = Response::new(StatusCode::Ok); res.append_header("Content-Type", "text/plain");
Set the body reader.
Examples
use http_types::{Response, StatusCode}; let mut res = Response::new(StatusCode::Ok); res.set_body("Hello, Nori!");
Replace the response body with a new body, returning the old body.
Examples
use http_types::{Body, Method, Response, StatusCode, Url}; let mut req = Response::new(StatusCode::Ok); req.set_body("Hello, Nori!"); let mut body: Body = req.replace_body("Hello, Chashu"); let mut string = String::new(); body.read_to_string(&mut string).await?; assert_eq!(&string, "Hello, Nori!");
Swaps the value of the body with another body, without deinitializing either one.
Examples
use http_types::{Body, Method, Response, StatusCode, Url}; let mut req = Response::new(StatusCode::Ok); req.set_body("Hello, Nori!"); let mut body = "Hello, Chashu!".into(); req.swap_body(&mut body); let mut string = String::new(); body.read_to_string(&mut string).await?; assert_eq!(&string, "Hello, Nori!");
Take the response body, replacing it with an empty body.
Examples
use http_types::{Body, Method, Response, StatusCode, Url}; let mut req = Response::new(StatusCode::Ok); req.set_body("Hello, Nori!"); let mut body: Body = req.take_body(); let mut string = String::new(); body.read_to_string(&mut string).await?; assert_eq!(&string, "Hello, Nori!");
Read the body as a string.
This consumes the response. If you want to read the body without
consuming the response, consider using the take_body
method and
then calling Body::into_string
or using the Response’s AsyncRead
implementation to read the body.
Examples
use async_std::io::Cursor; use http_types::{Body, Method, Response, StatusCode, Url}; let mut res = Response::new(StatusCode::Ok); let cursor = Cursor::new("Hello Nori"); let body = Body::from_reader(cursor, None); res.set_body(body); assert_eq!(&res.body_string().await.unwrap(), "Hello Nori");
Read the body as bytes.
This consumes the Response
. If you want to read the body without
consuming the response, consider using the take_body
method and
then calling Body::into_bytes
or using the Response’s AsyncRead
implementation to read the body.
Examples
use http_types::{Body, Method, Response, StatusCode, Url}; let bytes = vec![1, 2, 3]; let mut res = Response::new(StatusCode::Ok); res.set_body(Body::from_bytes(bytes)); let bytes = res.body_bytes().await?; assert_eq!(bytes, vec![1, 2, 3]);
Read the body as JSON.
This consumes the response. If you want to read the body without
consuming the response, consider using the take_body
method and
then calling Body::into_json
or using the Response’s AsyncRead
implementation to read the body.
Examples
use http_types::convert::{Deserialize, Serialize}; use http_types::{Body, Method, Response, StatusCode, Url}; #[derive(Debug, Serialize, Deserialize)] struct Cat { name: String, } let cat = Cat { name: String::from("chashu"), }; let mut res = Response::new(StatusCode::Ok); res.set_body(Body::from_json(&cat)?); let cat: Cat = res.body_json().await?; assert_eq!(&cat.name, "chashu");
Read the body as x-www-form-urlencoded
.
This consumes the request. If you want to read the body without
consuming the request, consider using the take_body
method and
then calling Body::into_json
or using the Response’s AsyncRead
implementation to read the body.
Examples
use http_types::convert::{Deserialize, Serialize}; use http_types::{Body, Method, Response, StatusCode, Url}; #[derive(Debug, Serialize, Deserialize)] struct Cat { name: String, } let cat = Cat { name: String::from("chashu"), }; let mut res = Response::new(StatusCode::Ok); res.set_body(Body::from_form(&cat)?); let cat: Cat = res.body_form().await?; assert_eq!(&cat.name, "chashu");
Set the response MIME.
Get the current content type
Get the length of the body stream, if it has been set.
This value is set when passing a fixed-size object into as the body.
E.g. a string, or a buffer. Consumers of this API should check this
value to decide whether to use Chunked
encoding, or set the
response length.
Returns true
if the set length of the body stream is zero, false
otherwise.
Get the HTTP version, if one has been set.
Examples
use http_types::{Response, StatusCode, Version}; let mut res = Response::new(StatusCode::Ok); assert_eq!(res.version(), None); res.set_version(Some(Version::Http2_0)); assert_eq!(res.version(), Some(Version::Http2_0));
Sets a string representation of the peer address that this response was sent to. This might take the form of an ip/fqdn and port or a local socket address.
Sets a string representation of the local address that this response was sent on. This might take the form of an ip/fqdn and port, or a local socket address.
Get the peer socket address for the underlying transport, if appropriate
Get the local socket address for the underlying transport, if appropriate
Set the HTTP version.
Examples
use http_types::{Response, StatusCode, Version}; let mut res = Response::new(StatusCode::Ok); res.set_version(Some(Version::Http2_0));
Set the status.
Sends trailers to the a receiver.
Receive trailers from a sender.
Returns true
if sending trailers is in progress.
This is supported on unstable
only.
unstable
only.Sends an upgrade connection to the a receiver.
This is supported on unstable
only.
unstable
only.Receive an upgraded connection from a sender.
This is supported on unstable
only.
unstable
only.Returns true
if a protocol upgrade is in progress.
An iterator visiting all header pairs in arbitrary order.
An iterator visiting all header pairs in arbitrary order, with mutable references to the values.
pub fn header_names(&self) -> Names<'_>ⓘNotable traits for Names<'a>impl<'a> Iterator for Names<'a> type Item = &'a HeaderName;
pub fn header_names(&self) -> Names<'_>ⓘNotable traits for Names<'a>impl<'a> Iterator for Names<'a> type Item = &'a HeaderName;
impl<'a> Iterator for Names<'a> type Item = &'a HeaderName;
An iterator visiting all header names in arbitrary order.
pub fn header_values(&self) -> Values<'_>ⓘNotable traits for Values<'a>impl<'a> Iterator for Values<'a> type Item = &'a HeaderValue;
pub fn header_values(&self) -> Values<'_>ⓘNotable traits for Values<'a>impl<'a> Iterator for Values<'a> type Item = &'a HeaderValue;
impl<'a> Iterator for Values<'a> type Item = &'a HeaderValue;
An iterator visiting all header values in arbitrary order.
Returns a reference to the existing local.
Returns a mutuable reference to the existing local state.
Examples
use http_types::{Response, StatusCode, Version}; let mut res = Response::new(StatusCode::Ok); res.ext_mut().insert("hello from the extension"); assert_eq!(res.ext().get(), Some(&"hello from the extension"));
Trait Implementations
Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
Attempt to read from the AsyncRead
into buf
. Read more
Performs the conversion.
Returns a reference to the value corresponding to the supplied name.
Panics
Panics if the name is not present in Response
.
type Output = HeaderValues
type Output = HeaderValues
The returned type after indexing.
Returns a reference to the value corresponding to the supplied name.
Panics
Panics if the name is not present in Response
.
type Output = HeaderValues
type Output = HeaderValues
The returned type after indexing.
type Item = (HeaderName, HeaderValues)
type Item = (HeaderName, HeaderValues)
The type of the elements being iterated over.
Auto Trait Implementations
impl !RefUnwindSafe for Response
impl !UnwindSafe for Response
Blanket Implementations
Returns the contents of the internal buffer, filling it with more data if empty. Read more
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
Reads all bytes and appends them into buf
until the delimiter byte
or EOF is found. Read more
Reads all bytes and appends them into buf
until a newline (the 0xA byte) or EOF is found. Read more
Returns a stream over the lines of this byte stream. Read more
Reads some bytes from the byte stream. Read more
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
Reads the exact number of bytes required to fill buf
. Read more
Creates an adapter which will read at most limit
bytes from it. Read more
Creates an adapter which will chain this stream with another. Read more
Mutably borrows from an owned value. Read more
Reads some bytes from the byte stream. Read more
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
Reads all bytes from the byte stream. Read more
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
Reads all bytes from the byte stream and appends them into a string. Read more
Reads the exact number of bytes required to fill buf
. Read more
Creates an adaptor which will read at most limit
bytes from it. Read more
Creates a “by reference” adaptor for this instance of Read
. Read more
Transforms this Read
instance to a Stream
over its bytes. Read more
type Output = T
type Output = T
Should always be Self