Struct RequestBody 

pub struct RequestBody { /* private fields */ }

A transport-independent, one-shot request body.

Owns the transfer-decoded byte stream from an HTTP request. No Hyper type appears in the public API.

Examples

use eggserve_core::primitives::{RequestBody, RequestBodyError};
use futures_util::StreamExt;

async fn handle(body: RequestBody) -> Result<Vec<u8>, RequestBodyError> {
    // Option 1: buffer everything
    let bytes = body.read_all().await?;
    Ok(bytes.to_vec())
}

async fn handle_streaming(mut body: RequestBody) -> Result<(), RequestBodyError> {
    // Option 2: stream chunks
    while let Some(chunk) = body.next_chunk().await? {
        let _ = chunk;
    }
    Ok(())
}

Implementations

impl RequestBody

pub fn empty() -> Self

Create an empty body with no declared length.

pub fn from_bytes(data: impl Into<Bytes>, max_bytes: u64) -> Self

Create a body from fixed bytes (test/experimental constructor).

The max_bytes parameter sets the effective limit. Use u64::MAX for unlimited.

pub fn declared_length(&self) -> Option<u64>

Returns the declared body length from Content-Length, if present.

pub fn bytes_received(&self) -> u64

Returns the number of bytes received so far.

pub fn is_complete(&self) -> bool

Returns true if the body has been fully consumed.

pub fn state(&self) -> BodyState

Returns the current consumption state.

pub fn max_bytes(&self) -> u64

Returns the effective byte limit.

pub async fn read_all(self) -> Result<Bytes, RequestBodyError>

Consume the entire body into a single Bytes value.

This is the simplest way to consume a body. After this call, the body is in the Complete state.

Errors

Returns an error if the body exceeds the limit, if the stream fails, or if the body was already consumed.

pub async fn next_chunk(&mut self) -> Result<Option<Bytes>, RequestBodyError>

Read the next chunk from the body.

Returns Ok(None) when the body is fully consumed. Returns Ok(Some(chunk)) with the next chunk of bytes.

After the first call to next_chunk, the body enters the Streaming state. Subsequent calls to read_all will fail with RequestBodyError::MixedConsumptionMode.

Errors

Returns an error if the body exceeds the limit, if the stream fails, or if the body was already consumed.

Trait Implementations

impl Debug for RequestBody

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

Formats the value using the given formatter.

impl Stream for RequestBody

type Item = Result<Bytes, RequestBodyError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.