Enum SendBody 

pub enum SendBody<W> {
    Raw(W),
    ContentLen(ContentLenWrite<W>),
    Chunked(ChunkedWrite<W>),
}

Represents an outgoing HTTP request stream body

Implements the Write trait to write the body to the stream

Variants

Raw(W)

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

ContentLen(ContentLenWrite<W>)

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

Chunked(ChunkedWrite<W>)

The body is chunked (Transfer-Encoding: chunked)

Implementations

impl<W> SendBody<W>

where W: Write,

pub fn new(body_type: BodyType, output: W) -> SendBody<W>

Create a new body

Parameters:

• body_type: The type of the body, as resolved using BodyType::resolve
• output: The raw output stream

pub fn is_complete(&self) -> bool

Check if the body has been completely written to

pub fn needs_close(&self) -> bool

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

pub async fn finish(&mut self) -> Result<(), Error<W::Error>>

where W: Write,

Finish writing the body (necessary for chunked encoding)

pub fn as_raw_writer(&mut self) -> &mut W

Return a mutable reference to the underlying raw writer

pub fn release(self) -> W

Release the body, returning the underlying raw writer

Trait Implementations

impl<W> ErrorType for SendBody<W>

where W: ErrorType,

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

Error type of all the IO operations on this type.

impl<W> Write for SendBody<W>

where W: Write,

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

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

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

Write an entire buffer into this writer.