Struct IncomingBody 

pub struct IncomingBody<'a, R> { /* private fields */ }

A pull body borrowing the connection’s input lane. Returning it as the response body provides streaming echo and managed duplex tunnels without boxing, queueing, spawning, or transferring socket ownership.

Reads are cancellation safe: dropping a pending read, or cancelling its wait, loses no input, and a later read resumes at the same position. This relies on R transferring bytes only within a read_into poll that returns them, as scheduler socket readers and the TLS stream do.

Trait Implementations

impl<R> Drop for IncomingBody<'_, R>

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<R: ReadableStream> ReadableBody for IncomingBody<'_, R>

type Data = Vec<u8>

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

type Error = Error

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_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, _: Option<Error>)

Abandon further application reads, optionally reporting their failure.

async fn read( &mut self, cancellation: &Cancellation, ) -> Result<BodyFrame<Vec<u8>>, Error>

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 is_rewindable(&self) -> bool

fn rewind(&mut self) -> bool

Restore the read position when supported, reporting success.