Enum OffloadKey 

pub enum OffloadKey {
    Keyed {
        key: CacheKey,
        kind: SmolStr,
    },
    Explicit {
        kind: SmolStr,
        id: u64,
    },
    Auto {
        kind: SmolStr,
    },
}

Key for identifying offloaded tasks.

This enum represents different types of keys that can be used to identify background tasks.

Variants

• Keyed: Key derived from a cache key.
• Explicit: Key with explicit id provided by caller.
• Auto: Key with auto-assigned id (manager assigns).

Variants

Keyed

Key derived from cache key.

Fields

key: CacheKey

The cache key.

kind: SmolStr

Kind of the task (e.g., “revalidate”, “cache_write”).

Explicit

Key with explicit id provided by caller.

Fields

kind: SmolStr

Kind of the task (e.g., “cleanup”, “metrics”).

id: u64

Unique identifier within the kind.

Auto

Key with auto-assigned id (manager assigns internally).

Fields

kind: SmolStr

Kind of the task (e.g., “race_loser”, “background”).

Implementations

impl OffloadKey

pub fn keyed(key: CacheKey, kind: impl Into<SmolStr>) -> Self

Create a keyed offload key derived from a cache key.

Example

use hitbox_core::{CacheKey, OffloadKey};

let cache_key = CacheKey::from_str("user", "123");
let key = OffloadKey::keyed(cache_key, "revalidate");

pub fn explicit(kind: impl Into<SmolStr>, id: u64) -> Self

Create a key with explicit id provided by caller.

Example

use hitbox_core::OffloadKey;

let key = OffloadKey::explicit("cleanup", 42);

pub fn auto(kind: impl Into<SmolStr>) -> Self

Create an auto key where manager assigns id internally.

Example

use hitbox_core::OffloadKey;

let key = OffloadKey::auto("race_loser");

pub fn kind(&self) -> &SmolStr

Returns the kind of this key.

Used for metrics labels and tracing.

Trait Implementations

impl Clone for OffloadKey

fn clone(&self) -> OffloadKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OffloadKey

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

Formats the value using the given formatter.

impl Eq for OffloadKey

impl<S: Into<SmolStr>> From<(CacheKey, S)> for OffloadKey

Conversion from (CacheKey, S) tuple to OffloadKey::Keyed.

Example

use hitbox_core::{CacheKey, OffloadKey};

let cache_key = CacheKey::from_str("user", "123");
let offload_key: OffloadKey = (cache_key, "revalidate").into();

fn from((key, kind): (CacheKey, S)) -> Self

Converts to this type from the input type.

impl Hash for OffloadKey

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 OffloadKey

fn eq(&self, other: &OffloadKey) -> 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 StructuralPartialEq for OffloadKey