Enum CollectExactResult 

pub enum CollectExactResult<B: HttpBody> {
    AtLeast {
        buffered: Bytes,
        remaining: Option<Remaining<B>>,
    },
    Incomplete {
        buffered: Option<Bytes>,
        error: Option<B::Error>,
    },
}

Result of attempting to collect at least N bytes from a body.

Returned by BufferedBody::collect_exact to indicate whether the requested number of bytes was successfully read from the stream.

When to Use

Use this when you need to inspect a fixed-size prefix of a body without consuming the entire stream:

• Checking magic bytes for file type detection
• Reading protocol headers
• Validating body format before full processing

Invariants

• AtLeast: buffered.len() >= requested_bytes
• Incomplete: buffered.len() < requested_bytes (stream ended or error)
• The buffered data may exceed the requested size if a frame boundary didn’t align exactly

Examples

use hitbox_http::{BufferedBody, CollectExactResult};

async fn example<B: hyper::body::Body + Unpin>(body: BufferedBody<B>) {
    // Check if body starts with JSON array
    let result = body.collect_exact(1).await;
    match result {
        CollectExactResult::AtLeast { ref buffered, .. } => {
            if buffered.starts_with(b"[") {
                // It's a JSON array, reconstruct body for further processing
                let body = result.into_buffered_body();
            }
        }
        CollectExactResult::Incomplete { buffered, error } => {
            // Body was empty or error occurred
        }
    }
}

Variants

AtLeast

Successfully collected at least the requested number of bytes.

The buffered bytes contains at least the requested amount (possibly more if a frame was consumed). The remaining field contains either:

• Some(Remaining::Body(stream)) - more data to stream
• Some(Remaining::Error(err)) - error occurred after collecting enough bytes
• None - stream ended cleanly

Fields

buffered: Bytes

The bytes successfully read from the stream (at least limit_bytes).

remaining: Option<Remaining<B>>

The remaining stream data, if any.

Incomplete

Failed to collect the requested bytes.

This occurs when either:

• The body stream ended before reaching the requested number of bytes (error is None)
• An error occurred while reading the stream (error is Some)

The buffered field contains any bytes successfully read before the failure.

Fields

buffered: Option<Bytes>

Bytes read before the stream ended or error occurred.

error: Option<B::Error>

The error that occurred, if any.

Implementations

impl<B: HttpBody> CollectExactResult<B>

pub fn into_buffered_body(self) -> BufferedBody<B>

Converts the result into a BufferedBody, using the buffered data as prefix.

This reconstructs the body:

• AtLeast { buffered, remaining } → BufferedBody::Partial with buffered as prefix and remaining, or BufferedBody::Complete if no remaining
• Incomplete { buffered, error } → BufferedBody::Partial with error, or BufferedBody::Complete if no error

Trait Implementations

impl<B: Debug + HttpBody> Debug for CollectExactResult<B>

where B::Error: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.