Enum Body 

pub enum Body<'b, R> {
    Raw(PartiallyRead<'b, R>),
    ContentLen(ContentLenRead<PartiallyRead<'b, R>>),
    Chunked(ChunkedRead<'b, PartiallyRead<'b, R>>),
}

Represents an incoming HTTP request stream body

Implements the Read trait to read the body from the stream

Variants

Raw(PartiallyRead<'b, R>)

The body is raw and should be read as is (only possible for HTTP responses with connection = Close)

ContentLen(ContentLenRead<PartiallyRead<'b, R>>)

The body is of a known length (Content-Length)

Chunked(ChunkedRead<'b, PartiallyRead<'b, R>>)

The body is chunked (Transfer-Encoding: chunked)

Implementations

impl<'b, R> Body<'b, R>

where R: Read,

pub fn new( body_type: BodyType, buf: &'b mut [u8], read_len: usize, input: R, ) -> Self

Create a new body

Parameters:

• body_type: The type of the body, as resolved using BodyType::resolve
• buf: The buffer to use for reading the body
• read_len: The length of the buffer that has already been read when processing the icoming headers
• input: The raw input stream

pub fn needs_close(&self) -> bool

Check if the body needs to be closed (i.e. the underlying input stream cannot be re-used for Keep-Alive connections)

pub fn is_complete(&self) -> bool

Check if the body has been completely read

pub fn as_raw_reader(&mut self) -> &mut R

Return a mutable reference to the underlying raw reader

pub fn release(self) -> R

Release the body, returning the underlying raw reader

Trait Implementations

impl<R> ErrorType for Body<'_, R>

where R: ErrorType,

type Error = Error<<R as ErrorType>::Error>

Error type of all the IO operations on this type.

impl<R> Read for Body<'_, R>

where R: Read,

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.