Struct CacheKey 

pub struct CacheKey { /* private fields */ }

A cache key identifying a cached entry.

Cache keys are composed of:

• A prefix for namespacing (e.g., “api”, “users”)
• A version number for cache invalidation
• A list of parts (key-value pairs) extracted from requests

Cheap Cloning

CacheKey wraps its data in Arc, making clone() an O(1) operation that only increments a reference count. This is important because keys are frequently passed around during cache operations.

Example

use hitbox_core::{CacheKey, KeyPart};

let key = CacheKey::new(
    "api",
    1,
    vec![
        KeyPart::new("method", Some("GET")),
        KeyPart::new("path", Some("/users/123")),
    ],
);

assert_eq!(key.prefix(), "api");
assert_eq!(key.version(), 1);
assert_eq!(format!("{}", key), "api:v1:method=GET&path=/users/123");

Implementations

impl CacheKey

pub fn parts(&self) -> impl Iterator<Item = &KeyPart>

Returns an iterator over the key parts.

pub fn version(&self) -> u32

Returns the cache key version number.

pub fn prefix(&self) -> &str

Returns the cache key prefix.

pub fn memory_size(&self) -> usize

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

This includes:

• Arc heap allocation (control block + CacheKeyInner)
• Vec heap allocation (KeyPart elements)
• SmolStr heap allocations (strings >23 bytes)

pub fn new( prefix: impl Into<SmolStr>, version: u32, parts: Vec<KeyPart>, ) -> Self

Creates a new cache key with the given components.

Arguments

• prefix - Namespace prefix for the key
• version - Version number for cache invalidation
• parts - List of key-value parts

pub fn from_str(key: &str, value: &str) -> Self

Creates a simple cache key with a single key-value part.

The prefix is empty and version is 0.

pub fn from_slice(parts: &[(&str, Option<&str>)]) -> Self

Creates a cache key from a slice of key-value pairs.

The prefix is empty and version is 0.

Trait Implementations

impl Clone for CacheKey

fn clone(&self) -> CacheKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheKey

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

Formats the value using the given formatter.

impl Display for CacheKey

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

Formats the value using the given formatter.

impl Hash for CacheKey

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CacheKey

fn eq(&self, other: &Self) -> 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 Serialize for CacheKey

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de> Decode<'de> for CacheKey

impl Encode for CacheKey

impl Eq for CacheKey