Struct CacheableHttpResponse 

pub struct CacheableHttpResponse<ResBody>
where
    ResBody: Body,
{
    pub parts: Parts,
    pub body: BufferedBody<ResBody>,
}

Wraps an HTTP response for cache storage and retrieval.

This type holds the response metadata (Parts) and a BufferedBody. When caching, the body is collected into bytes and stored as a SerializableHttpResponse. When retrieving from cache, the response is reconstructed with a BufferedBody::Complete containing the cached bytes.

Type Parameters

• ResBody - The HTTP response body type. Must implement hyper::body::Body with Send bounds. Common concrete types:
  • Empty<Bytes> - No body (204 responses)
  • Full<Bytes> - Complete body in memory
  • BoxBody<Bytes, E> - Type-erased body for dynamic dispatch

Examples

use bytes::Bytes;
use http::Response;
use http_body_util::Empty;
use hitbox_http::{BufferedBody, CacheableHttpResponse};

let response = Response::builder()
    .status(200)
    .header("Content-Type", "application/json")
    .body(BufferedBody::Passthrough(Empty::<Bytes>::new()))
    .unwrap();

let cacheable = CacheableHttpResponse::from_response(response);

Cache Storage

When a response is cacheable, the body is fully collected and stored as SerializableHttpResponse. This means:

• The entire response body must fit in memory
• Streaming responses are buffered before storage
• Body collection errors result in a NonCacheable policy

Performance

Retrieving a cached response is allocation-efficient: the body bytes are wrapped directly in BufferedBody::Complete without copying.

Fields

parts: Parts

Response metadata (status, version, headers, extensions).

body: BufferedBody<ResBody>

The response body in one of three buffering states.

Implementations

impl<ResBody> CacheableHttpResponse<ResBody>

where ResBody: Body,

pub fn from_response( response: Response<BufferedBody<ResBody>>, ) -> CacheableHttpResponse<ResBody>

Creates a cacheable response from an HTTP response with a buffered body.

The response body must already be wrapped in a BufferedBody. Use BufferedBody::Passthrough for responses that haven’t been inspected yet.

pub fn into_response(self) -> Response<BufferedBody<ResBody>>

Converts back into a standard HTTP response.

Use this after cache policy evaluation to send the response to the client.

Trait Implementations

impl<ResBody> CacheStatusExt for CacheableHttpResponse<ResBody>

where ResBody: Body,

type Config = HeaderName

Configuration type for applying cache status (e.g., header name for HTTP).

fn cache_status( &mut self, status: CacheStatus, config: &<CacheableHttpResponse<ResBody> as CacheStatusExt>::Config, )

Applies cache status information to the response.

impl<ResBody> CacheableResponse for CacheableHttpResponse<ResBody>

where ResBody: Body + Send + 'static, <ResBody as Body>::Error: Send, <ResBody as Body>::Data: Send,

type Cached = SerializableHttpResponse

The serializable type stored in cache.

type Subject = CacheableHttpResponse<ResBody>

The type that response predicates evaluate.

type IntoCachedFuture = Pin<Box<dyn Future<Output = CachePolicy<<CacheableHttpResponse<ResBody> as CacheableResponse>::Cached, CacheableHttpResponse<ResBody>>> + Send>>

Future type for into_cached method.

type FromCachedFuture = Ready<CacheableHttpResponse<ResBody>>

Future type for from_cached method.

async fn cache_policy<P>( self, predicates: P, config: &EntityPolicyConfig, ) -> CachePolicy<CacheValue<<CacheableHttpResponse<ResBody> as CacheableResponse>::Cached>, CacheableHttpResponse<ResBody>>

where P: Predicate<Subject = <CacheableHttpResponse<ResBody> as CacheableResponse>::Subject> + Send + Sync,

Determine if this response should be cached.

fn into_cached( self, ) -> <CacheableHttpResponse<ResBody> as CacheableResponse>::IntoCachedFuture

Convert this response to its cached representation.

fn from_cached( cached: <CacheableHttpResponse<ResBody> as CacheableResponse>::Cached, ) -> <CacheableHttpResponse<ResBody> as CacheableResponse>::FromCachedFuture

Reconstruct a response from cached data.

impl<ResBody> CacheableSubject for CacheableHttpResponse<ResBody>

where ResBody: Body,

type Body = ResBody

The HTTP body type.

type Parts = Parts

The metadata type (e.g., http::request::Parts or http::response::Parts).

fn into_parts( self, ) -> (<CacheableHttpResponse<ResBody> as CacheableSubject>::Parts, BufferedBody<<CacheableHttpResponse<ResBody> as CacheableSubject>::Body>)

Decomposes this subject into metadata and body.

fn from_parts( parts: <CacheableHttpResponse<ResBody> as CacheableSubject>::Parts, body: BufferedBody<<CacheableHttpResponse<ResBody> as CacheableSubject>::Body>, ) -> CacheableHttpResponse<ResBody>

Reconstructs a subject from metadata and body.

impl<ResBody> Debug for CacheableHttpResponse<ResBody>

where ResBody: Debug + Body,

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

Formats the value using the given formatter.

impl<ResBody> HasHeaders for CacheableHttpResponse<ResBody>

where ResBody: Body,

fn headers(&self) -> &HeaderMap

Returns a reference to the HTTP headers.

impl<ResBody> HasVersion for CacheableHttpResponse<ResBody>

where ResBody: Body,

fn http_version(&self) -> Version

Returns the HTTP protocol version.