Struct CacheableHttpRequest 

pub struct CacheableHttpRequest<ReqBody>
where
    ReqBody: HttpBody,
{ /* private fields */ }

Wraps an HTTP request for cache policy evaluation.

This type holds the request metadata (Parts) and a BufferedBody that allows predicates and extractors to inspect the request without fully consuming the body stream.

Type Parameters

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

Examples

use bytes::Bytes;
use http::Request;
use http_body_util::Empty;
use hitbox_http::{BufferedBody, CacheableHttpRequest};

let request = Request::builder()
    .method("GET")
    .uri("/users/42")
    .header("Authorization", "Bearer token")
    .body(BufferedBody::Passthrough(Empty::<Bytes>::new()))
    .unwrap();

let cacheable = CacheableHttpRequest::from_request(request);

Extracting Cache Keys

Use with extractors to generate cache key parts:

use hitbox::Extractor;
use hitbox_http::CacheableHttpRequest;
use hitbox_http::extractors::{Method, path::PathExtractor};

async fn example(cacheable: CacheableHttpRequest<Empty<Bytes>>) {
    let extractor = Method::new().path("/users/{user_id}");
    let key_parts = extractor.get(cacheable).await;
}

Implementations

impl<ReqBody> CacheableHttpRequest<ReqBody>

where ReqBody: HttpBody,

pub fn from_request(request: Request<BufferedBody<ReqBody>>) -> Self

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

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

pub fn into_request(self) -> Request<BufferedBody<ReqBody>>

Converts back into a standard HTTP request.

Use this after cache policy evaluation to continue processing the request.

pub fn parts(&self) -> &Parts

Returns a reference to the request metadata.

The Parts contain the method, URI, version, headers, and extensions.

pub fn into_parts(self) -> (Parts, BufferedBody<ReqBody>)

Decomposes into metadata and body.

This is equivalent to CacheableSubject::into_parts.

Trait Implementations

impl<ReqBody> CacheableRequest for CacheableHttpRequest<ReqBody>

where ReqBody: HttpBody + Send + 'static, ReqBody::Error: Send,

async fn cache_policy<P, E>( self, predicates: P, extractors: E, ) -> RequestCachePolicy<Self>

where P: Predicate<Subject = Self> + Send + Sync, E: Extractor<Subject = Self> + Send + Sync,

Determine if this request should be cached and extract its key.

impl<ReqBody> CacheableSubject for CacheableHttpRequest<ReqBody>

where ReqBody: HttpBody,

type Body = ReqBody

The HTTP body type.

type Parts = Parts

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

fn into_parts(self) -> (Self::Parts, BufferedBody<Self::Body>)

Decomposes this subject into metadata and body.

fn from_parts(parts: Self::Parts, body: BufferedBody<Self::Body>) -> Self

Reconstructs a subject from metadata and body.

impl<ReqBody> Debug for CacheableHttpRequest<ReqBody>

where ReqBody: HttpBody + Debug,

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

Formats the value using the given formatter.

impl<ReqBody> HasHeaders for CacheableHttpRequest<ReqBody>

where ReqBody: HttpBody,

fn headers(&self) -> &HeaderMap

Returns a reference to the HTTP headers.

impl<ReqBody> HasVersion for CacheableHttpRequest<ReqBody>

where ReqBody: HttpBody,

fn http_version(&self) -> Version

Returns the HTTP protocol version.