Enum StreamingBody

pub enum StreamingBody<B> {
    Buffered {
        data: Option<Bytes>,
    },
    Streaming {
        inner: B,
    },
}

A body type that can represent either buffered data from cache or streaming body from upstream.

This enum allows the HTTP cache middleware to efficiently handle:

• Cached responses (buffered data)
• Cache misses (streaming from upstream)

Variants

• Buffered: Contains cached response data that can be sent immediately
• Streaming: Wraps an upstream body for streaming responses

Example

use http_cache::StreamingBody;
use bytes::Bytes;
use http_body_util::Full;

// Cached response - sent immediately from memory
let cached: StreamingBody<Full<Bytes>> = StreamingBody::buffered(Bytes::from("Hello from cache!"));

// Streaming response - passed through from upstream
let upstream_body = MyBody;
let streaming = StreamingBody::streaming(upstream_body);

Variants

Buffered

Fields

data: Option<Bytes>

Streaming

Fields

inner: B

Implementations

impl<B> StreamingBody<B>

pub fn buffered(data: Bytes) -> Self

Create a new buffered body from bytes

pub fn streaming(body: B) -> Self

Create a new streaming body from an upstream body

Trait Implementations

impl<B> Body for StreamingBody<B>

where B: Body + Unpin, B::Error: Into<StreamingError>, B::Data: Into<Bytes>,

type Data = Bytes

Values yielded by the Body.

type Error = StreamingError

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<B> From<Bytes> for StreamingBody<B>

fn from(bytes: Bytes) -> Self

Converts to this type from the input type.

impl<'__pin, B> Unpin for StreamingBody<B>

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