Struct RequestBodyStream 

pub struct RequestBodyStream { /* private fields */ }

A streaming request body.

This provides an async interface for reading request body chunks without buffering the entire body in memory.

Example

use fastapi_core::{Body, RequestBodyStream};

async fn handle_upload(body: Body) -> Vec<u8> {
    match body {
        Body::Stream(mut stream) => {
            let mut buffer = Vec::new();
            while let Some(chunk) = stream.next().await {
                buffer.extend_from_slice(&chunk?);
            }
            buffer
        }
        Body::Bytes(bytes) => bytes,
        Body::Empty => Vec::new(),
    }
}

Implementations

impl RequestBodyStream

pub fn new<S>(stream: S) -> Self

where S: Stream<Item = Result<Vec<u8>, RequestBodyStreamError>> + Send + Sync + 'static,

Create a new body stream from an async stream of chunks.

pub fn with_expected_size<S>(stream: S, expected_size: usize) -> Self

where S: Stream<Item = Result<Vec<u8>, RequestBodyStreamError>> + Send + Sync + 'static,

Create a body stream with a known expected size.

pub fn bytes_received(&self) -> usize

Returns the number of bytes received so far.

pub fn expected_size(&self) -> Option<usize>

Returns the expected total size, if known.

pub fn is_complete(&self) -> bool

Returns true if the stream is complete.

pub async fn collect(self) -> Result<Vec<u8>, RequestBodyStreamError>

Collect all chunks into a single buffer.

This consumes the stream and buffers the entire body in memory. Use this for small bodies or when the full content is needed.

For large bodies, prefer processing chunks individually via next().

Trait Implementations

impl Debug for RequestBodyStream

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

Formats the value using the given formatter.

impl Stream for RequestBodyStream

type Item = Result<Vec<u8>, RequestBodyStreamError>

The type of 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.

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

Returns the bounds on the remaining length of the stream.