Struct LimitedBody 

pub struct LimitedBody { /* private fields */ }

Body wrapper that enforces size limits during streaming.

Created by HttpResponse::into_limited_body(). Tracks bytes read and returns HttpError::BodyTooLarge if the limit is exceeded.

Unlike reading the body with HttpResponse::bytes() or HttpResponse::json(), this allows incremental processing while still enforcing limits.

Example

use http_body_util::BodyExt;

let response = client.get("https://example.com/large-file").send().await?;
let mut body = response.into_limited_body();

while let Some(frame) = body.frame().await {
    let frame = frame?; // Returns BodyTooLarge if limit exceeded
    if let Some(chunk) = frame.data_ref() {
        process_chunk(chunk);
    }
}

Implementations

impl LimitedBody

pub fn new(inner: ResponseBody, limit: usize) -> Self

Creates a new LimitedBody wrapping the given body with the specified limit.

pub fn bytes_read(&self) -> usize

Returns the number of bytes read so far.

pub fn limit(&self) -> usize

Returns the configured size limit.

Trait Implementations

impl Body for LimitedBody

type Data = Bytes

Values yielded by the Body.

type Error = HttpError

The error type this Body might generate.

fn poll_frame( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>>

Attempt to pull out the next data buffer of this stream.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.

impl<'__pin> Unpin for LimitedBody

where PinnedFieldsOf<__Origin<'__pin>>: Unpin,