Struct SlotCache 

pub struct SlotCache<V: Copy, const N: usize, const MAX_KEY: usize> { /* private fields */ }

Keyed, fixed-capacity cache with LRU eviction and pinning.

Implementations

impl<V: Copy, const N: usize, const MAX_KEY: usize> SlotCache<V, N, MAX_KEY>

pub const fn new() -> Self

An empty cache. const so it can back a static.

pub const fn capacity(&self) -> usize

Slot capacity.

pub fn bump_epoch(&mut self)

Advance the LRU clock. Call once per cache cycle (e.g. per frame) so get touches and eviction comparisons share a monotonic timeline. Never returns 0, so a freshly touched slot always beats the initial last_used of an untouched one.

pub const fn epoch(&self) -> u32

The current epoch (the value get stamps into last_used).

pub fn slot_of(&self, key: u16) -> Option<usize>

Slot index currently mapped to key in any non-empty state, validated against the forward store (so a stale reverse entry never lies).

pub fn contains_ready(&self, key: u16) -> bool

Is key resident and usable (Ready)?

pub fn is_loading(&self, key: u16) -> bool

Is key reserved with a load in flight (Loading)?

pub fn state_of(&self, key: u16) -> SlotState

Load state of key, or Empty if absent.

pub fn get(&mut self, key: u16) -> Option<&V>

Get a Ready value, marking it most-recently-used. Returns None for an absent or still-Loading key.

pub fn peek(&self, key: u16) -> Option<&V>

Like get but without touching the LRU clock.

pub fn begin_load(&mut self, key: u16) -> Option<Reservation>

Reserve a slot for key and mark it Loading, evicting the least-recently-used unpinned Ready slot if the cache is full. Returns a Reservation for the caller to complete with finish_load, or None if key is out of range or every slot is pinned or already loading. If key already has a slot, a reservation for that slot is returned unchanged (no duplicate load is started).

pub fn finish_load( &mut self, reservation: Reservation, value: V, ) -> Result<(), Stale>

Complete a begin_load: store the value and mark the slot Ready and most-recently-used. Returns Stale when the reservation’s key no longer owns its slot (it was evicted, and the slot may now be loading another key), and stores nothing.

pub fn reserve(&mut self, key: u16) -> Option<usize>

👎Deprecated:

renamed to begin_load

Renamed to begin_load, which returns the key with the slot so a stale completion can be told from a live one.

pub fn mark_ready(&mut self, slot: usize, value: V)

👎Deprecated:

renamed to finish_load, which checks the key still owns the slot

Renamed to finish_load. A bare slot index cannot tell that the slot was evicted and reused for another key since reserve, so a late completion stores its value under the wrong key; this keeps that behaviour for one stage.

pub fn get_or_insert_with<F>(&mut self, key: u16, build: F) -> Option<&V>

where F: FnOnce() -> Option<V>,

Return the cached value for key, or synchronously build and insert it. Evicts LRU on a miss when full. If build returns None the reservation is released and this returns None.

pub fn pin(&mut self, key: u16)

Pin key’s slot so it is never evicted. No-op if absent.

pub fn unpin_all(&mut self)

Clear all pins.

pub fn set_pinned(&mut self, keys: &[u16])

Replace the pin set: unpin everything, then pin each present key in keys. This is the “declare the working set” call a streaming reconcile makes each cycle.

pub fn evict(&mut self, key: u16)

Evict key (any state) back to Empty. No-op if absent.

pub fn evict_ready_outside(&mut self, keep: &[u16]) -> usize

Evict every Ready, unpinned slot whose key is not in keep. Used by a reconcile to drop rooms that left the desired set while protecting the pinned working set. Returns the number evicted.

pub fn ready_len(&self) -> usize

Number of Ready slots.

pub fn len(&self) -> usize

Number of occupied (Loading or Ready) slots.

pub fn is_empty(&self) -> bool

Whether no slot is occupied.

Trait Implementations

impl<V: Copy, const N: usize, const MAX_KEY: usize> Default for SlotCache<V, N, MAX_KEY>

fn default() -> Self

Returns the “default value” for a type.