[−][src]Struct http_types::Body
A streaming HTTP body.
Body represents the HTTP body of both Request and Response. It's completely
streaming, and implements AsyncBufRead to make reading from it both convenient and
performant.
Both Request and Response take Body by Into<Body>, which means that passing string
literals, byte vectors, but also concrete Body instances are all valid. This makes it
easy to create both quick HTTP requests, but also have fine grained control over how bodies
are streamed out.
Examples
use http_types::{Body, Response, StatusCode}; use async_std::io::Cursor; let mut req = Response::new(StatusCode::Ok); req.set_body("Hello Chashu"); let mut req = Response::new(StatusCode::Ok); let cursor = Cursor::new("Hello Nori"); let body = Body::from_reader(cursor, Some(10)); // set the body length req.set_body(body);
Length
One of the details of Body to be aware of is the length parameter. The value of
length is used by HTTP implementations to determine how to treat the stream. If a length
is known ahead of time, it's strongly recommended to pass it.
Casting from Vec<u8>, String, or similar to Body will automatically set the value of
length.
Content Encoding
By default Body will come with a fallback Mime type that is used by Request and
Response if no other type has been set, and no other Mime type can be inferred.
It's strongly recommended to always set a mime type on both the Request and Response,
and not rely on the fallback mechanisms. However, they're still there if you need them.
Implementations
impl Body[src]
pub fn empty() -> Self[src]
Create a new empty Body.
The body will have a length of 0, and the Mime type set to application/octet-stream if
no other mime type has been set or can be sniffed.
Examples
use http_types::{Body, Response, StatusCode}; let mut req = Response::new(StatusCode::Ok); req.set_body(Body::empty());
pub fn from_reader(
reader: impl BufRead + Unpin + Send + Sync + 'static,
len: Option<usize>
) -> Self[src]
reader: impl BufRead + Unpin + Send + Sync + 'static,
len: Option<usize>
) -> Self
Create a Body from a reader with an optional length.
The Mime type set to application/octet-stream if no other mime type has been set or can
be sniffed. If a Body has no length, HTTP implementations will often switch over to
framed messages such as Chunked
Encoding.
Examples
use http_types::{Body, Response, StatusCode}; use async_std::io::Cursor; let mut req = Response::new(StatusCode::Ok); let cursor = Cursor::new("Hello Nori"); let len = 10; req.set_body(Body::from_reader(cursor, Some(len)));
pub fn len(&self) -> Option<usize>[src]
Get the length of the body in bytes.
Examples
use http_types::Body; use async_std::io::Cursor; let cursor = Cursor::new("Hello Nori"); let len = 10; let body = Body::from_reader(cursor, Some(len)); assert_eq!(body.len(), Some(10));
pub fn is_empty(&self) -> Option<bool>[src]
Returns true if the body has a length of zero, and false otherwise.
pub fn into_reader(self) -> Box<dyn BufRead + Unpin + Send + 'static>[src]
Get the inner reader from the Body
Examples
use http_types::Body; use async_std::io::Cursor; let cursor = Cursor::new("Hello Nori"); let body = Body::from_reader(cursor, None); let _ = body.into_reader();
pub async fn into_string(__arg0: Self) -> Result<String>[src]
Read the body as a string
Examples
use http_types::Body; use async_std::io::Cursor; let cursor = Cursor::new("Hello Nori"); let body = Body::from_reader(cursor, None); assert_eq!(&body.into_string().await.unwrap(), "Hello Nori");
Trait Implementations
impl AsyncBufRead for Body[src]
fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<&[u8]>>[src]
fn consume(self: Pin<&mut Self>, amt: usize)[src]
impl AsyncRead for Body[src]
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut [u8]
) -> Poll<Result<usize>>[src]
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut [u8]
) -> Poll<Result<usize>>
fn poll_read_vectored(
self: Pin<&mut Self>,
cx: &mut Context,
bufs: &mut [IoSliceMut]
) -> Poll<Result<usize, Error>>[src]
self: Pin<&mut Self>,
cx: &mut Context,
bufs: &mut [IoSliceMut]
) -> Poll<Result<usize, Error>>
impl Debug for Body[src]
impl<'a> From<&'a str> for Body[src]
impl From<Request> for Body[src]
impl From<Response> for Body[src]
impl From<String> for Body[src]
impl From<Vec<u8>> for Body[src]
impl<'__pin> Unpin for Body where
__Origin<'__pin>: Unpin, [src]
__Origin<'__pin>: Unpin,
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<R> AsyncBufReadExt for R where
R: AsyncBufRead + ?Sized, [src]
R: AsyncBufRead + ?Sized,
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntil<'a, Self> where
Self: Unpin, [src]
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntil<'a, Self> where
Self: Unpin,
fn read_line(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn lines(self) -> Lines<Self>[src]
impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized, [src]
R: AsyncRead + ?Sized,
fn chain<R>(self, next: R) -> Chain<Self, R> where
R: AsyncRead, [src]
R: AsyncRead,
fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectored<'a, Self> where
Self: Unpin, [src]
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectored<'a, Self> where
Self: Unpin,
fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn read_to_end(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn read_to_string(&'a mut self, buf: &'a mut String) -> ReadToString<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite, [src]
Self: AsyncWrite,
fn take(self, limit: u64) -> Take<Self>[src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<T> BufReadExt for T where
T: AsyncBufRead + ?Sized, [src]
T: AsyncBufRead + ?Sized,
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin, [src]
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
fn read_line(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn lines(self) -> Lines<Self> where
Self: Unpin, [src]
Self: Unpin,
fn split(self, byte: u8) -> Split<Self>[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> ReadExt for T where
T: AsyncRead + ?Sized, [src]
T: AsyncRead + ?Sized,
fn read(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin, [src]
&'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>) -> ReadToEndFuture<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin, [src]
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> where
Self: Unpin, [src]
Self: Unpin,
fn take(self, limit: u64) -> Take<Self>[src]
fn by_ref(&mut self) -> &mut Self[src]
fn bytes(self) -> Bytes<Self>[src]
fn chain<R>(self, next: R) -> Chain<Self, R> where
R: AsyncRead, [src]
R: AsyncRead,
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,