Struct PartialBufferedBody 

pub struct PartialBufferedBody<B>
where
    B: HttpBody,
{ /* private fields */ }

A partially consumed body: buffered prefix plus remaining stream.

Created when a predicate or extractor reads some bytes from a body stream without consuming it entirely. Implements HttpBody to transparently replay the buffered prefix followed by the remaining stream data.

When You’ll Encounter This

You typically don’t create this directly. It appears inside BufferedBody::Partial after operations like collect_exact.

Invariants

• The prefix contains bytes already read from the original stream
• The remaining stream has not been polled since the prefix was extracted
• When polled as HttpBody, prefix bytes are yielded before remaining data

Streaming Behavior

When polled as an HttpBody:

1. Yields the buffered prefix (if any) as a single frame
2. Delegates to the remaining stream, or yields the stored error

Examples

use bytes::Bytes;
use hitbox_http::{BufferedBody, PartialBufferedBody, Remaining};

fn example<B: hyper::body::Body>(body: BufferedBody<B>) {
    // Decompose a partial body
    if let BufferedBody::Partial(partial) = body {
        let prefix: Option<&Bytes> = partial.prefix();
        println!("Buffered {} bytes", prefix.map(|b| b.len()).unwrap_or(0));

        let (prefix, remaining) = partial.into_parts();
        // Can now handle prefix and remaining separately
    }
}

Performance

The prefix is yielded as a single frame, avoiding per-byte overhead. The remaining stream is passed through without additional buffering.

Implementations

impl<B> PartialBufferedBody<B>

where B: HttpBody,

pub fn new(prefix: Option<Bytes>, remaining: Remaining<B>) -> Self

Constructs a partial body for transparent stream replay.

When this body is polled as HttpBody, the prefix bytes are yielded first as a single frame, followed by the remaining stream data (or error). This enables predicates to inspect body content without losing data.

pub fn prefix(&self) -> Option<&Bytes>

Returns the bytes already consumed from the original stream.

These bytes will be replayed before any remaining stream data when this body is polled. Returns None if no bytes were buffered.

pub fn into_parts(self) -> (Option<Bytes>, Remaining<B>)

Separates the buffered prefix from the remaining stream for independent handling.

Use this when you need to process the prefix and remaining data differently, such as forwarding them to separate destinations.

Trait Implementations

impl<B: HttpBody> Body for PartialBufferedBody<B>

type Data = Bytes

Values yielded by the Body.

type Error = <B as Body>::Error

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 size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

impl<'pin, B> Unpin for PartialBufferedBody<B>

where B: HttpBody, PinnedFieldsOf<__PartialBufferedBody<'pin, B>>: Unpin,