Struct BodyWriter 

pub struct BodyWriter<D = Vec<u8>> { /* private fields */ }

The unique output half of a BodyReader body.

Finish with a terminal frame or close_write(None) to preserve queued frames. An error closes immediately and discards queued frames. Dropping unfinished output reports abandonment. A cancelled/pending write has not queued its frame; the supplied owner is dropped when that write future is dropped.

Implementations

impl<D: AsRef<[u8]> + Send> BodyWriter<D>

pub async fn write( &mut self, data: D, cancellation: &Cancellation, ) -> Result<(), BodyError>

pub async fn write_frame( &mut self, frame: BodyFrame<D>, cancellation: &Cancellation, ) -> Result<(), BodyError>

Move a whole frame into the queue. Headers must follow all data; an end flag or End closes output atomically with accepting that frame. Capacity counts data bytes and field name/value bytes, plus every frame against the item limit. As with data, owners may retain additional memory.

pub async fn flush( &mut self, cancellation: &Cancellation, ) -> Result<(), BodyError>

pub fn close_write(&mut self, error: Option<BodyError>)

pub fn abort(&mut self)

Trait Implementations

impl<D> Drop for BodyWriter<D>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<D: AsRef<[u8]> + Send> WritableBody for BodyWriter<D>

type Data = D

type Error = BodyError

async fn write_frame( &mut self, frame: BodyFrame<D>, cancellation: &Cancellation, ) -> Result<(), BodyError>

Accept one whole frame. Headers follow all data; a terminal frame closes output atomically with acceptance. Later writes fail. Queue capacity becoming available does not mean the transport has released its buffers.

async fn write( &mut self, data: D, cancellation: &Cancellation, ) -> Result<(), BodyError>

Write a nonfinal data frame. Use write_frame to carry fields or end.

async fn flush(&mut self, cancellation: &Cancellation) -> Result<(), BodyError>

fn close_write(&mut self, error: Option<BodyError>)

fn abort(&mut self)