Struct CacheValue 

pub struct CacheValue<T> { /* private fields */ }

A cached value with expiration metadata.

Wraps any data type T with optional timestamps for staleness and expiration. This enables time-based cache invalidation and stale-while-revalidate patterns.

Type Parameter

• T - The cached data type

Example

use hitbox_core::value::CacheValue;
use chrono::Utc;
use std::time::Duration;

// Create a cache value that expires in 1 hour
let expire_time = Utc::now() + chrono::Duration::hours(1);
let value = CacheValue::new("user_data", Some(expire_time), None);

// Access data via getter
assert_eq!(value.data(), &"user_data");

// Check remaining TTL
if let Some(ttl) = value.ttl() {
    println!("Expires in {} seconds", ttl.as_secs());
}

// Extract the data
let data = value.into_inner();

Implementations

impl<T> CacheValue<T>

pub fn new( data: T, expire: Option<DateTime<Utc>>, stale: Option<DateTime<Utc>>, ) -> Self

Creates a new cache value with the given data and timestamps.

Arguments

• data - The data to cache
• expire - When the data expires (becomes invalid)
• stale - When the data becomes stale (should refresh in background)

pub fn data(&self) -> &T

Returns a reference to the cached data.

pub fn expire(&self) -> Option<DateTime<Utc>>

Returns when the data expires (becomes invalid).

pub fn stale(&self) -> Option<DateTime<Utc>>

Returns when the data becomes stale (should refresh in background).

pub fn into_inner(self) -> T

Consumes the cache value and returns the inner data.

Discards the expiration metadata.

pub fn into_parts(self) -> (CacheMeta, T)

Consumes the cache value and returns metadata and data separately.

Useful when you need to inspect or modify the metadata independently.

pub fn ttl(&self) -> Option<Duration>

Calculate TTL (time-to-live) from the expire time.

Returns Some(Duration) if there’s a valid expire time in the future, or None if there’s no expire time or it’s already expired.

impl<T> CacheValue<T>

pub fn cache_state(self) -> CacheState<Self>

Check the cache state based on expire/stale timestamps.

Returns CacheState<CacheValue<T>> preserving the original value with metadata. This is a sync operation - just checks timestamps, no conversion.

The caller is responsible for converting to Response via from_cached() when needed.

impl CacheValue<Raw>

pub fn memory_size(&self) -> usize

Returns the estimated memory usage of this cache value in bytes.

This includes:

• Fixed struct overhead (CacheValue fields)
• The serialized data bytes

Trait Implementations

impl<T: Clone> Clone for CacheValue<T>

fn clone(&self) -> CacheValue<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for CacheValue<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for CacheValue<T>

fn eq(&self, other: &CacheValue<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for CacheValue<T>

impl<T> StructuralPartialEq for CacheValue<T>