Struct BodyReader 

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

The readable half of a bounded, single-producer body.

Byte limits count data and field name/value bytes; item limits count every frame, including empty data and headers. Oversized frames are rejected rather than waiting forever. Owners may retain additional storage. Dropping/closing the reader abandons queued frames and wakes the writer. A temporarily empty open body is neither ready nor exhausted.

Implementations

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

pub fn bounded(max_bytes: usize, max_chunks: usize) -> (Self, BodyWriter<D>)

Create independently movable input/output halves. Panics for zero limits.

pub fn with_length( max_bytes: usize, max_chunks: usize, length: u64, ) -> (Self, BodyWriter<D>)

Declare total representation length; protocol framing checks actual size.

Trait Implementations

impl<D> Drop for BodyReader<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> ReadableBody for BodyReader<D>

type Data = D

Application data, without imposing completion-I/O buffer requirements.

type Error = BodyError

fn is_ready(&self) -> bool

Whether another read can proceed without waiting for produced data.

fn is_empty(&self) -> bool

Whether no unread payload frames remain. False can mean unknown; an open queue with no frames is not exhausted. This does not suppress read errors.

fn length(&self) -> Option<u64>

Total representation length, independent of the current read position.

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

Abandon further application reads, optionally reporting their failure.

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

Read one owned frame. Pre-cancellation prevents consumption. The caller stops after frame.is_end(); subsequent reads return BodyFrame::End. Headers occur at most once, after all data. Dropping a pending read is not transport retirement, and must not lose an unreturned queued frame.

fn may_have_trailers(&self) -> bool

Whether this body can emit trailing headers. HTTP/1 needs this before reading to choose chunked framing, even when the data length is known. Returning false promises that no Headers frame will be produced.

fn is_rewindable(&self) -> bool

fn rewind(&mut self) -> bool

Restore the read position when supported, reporting success.