Struct Cache 

pub struct Cache<A, K, V, Route>
where
    A: Address,
    Route: DeliveryRoute,
    Route::Protocol: Protocol<Addr = A, Msg = CacheResult<K, V>>,
{ /* private fields */ }

Bounded deterministic recency cache behavior.

State is CacheState in least- to most-recent order. Put and successful get move the key to the most-recent position. Replacement returns the old value; capacity eviction returns the complete oldest entry. Miss and absent are factual results, not errors. Every command emits exactly one typed result after committing its state transition. Initialization is empty, no actors are created, and the cache never terminates itself. Recency and eviction are Bombay policy, not durability: Mnesis remains the durable authority. The standard-library vector is intentional for this initial deterministic policy; an lru dependency requires a demonstrated scale need and must remain private. No method has a semantic panic condition.

Implementations

impl<A, K, V, Route> Cache<A, K, V, Route>

where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = CacheResult<K, V>>,

pub fn new(configuration: CacheConfiguration) -> Self

Bind validated capacity to an empty cache actor.

pub const fn state(&self) -> &CacheState<K, V>

Borrow the complete current recency state.

Trait Implementations

impl<A, K, V, Route> Behavior for Cache<A, K, V, Route>

where A: Address, K: Clone + Eq, V: Clone, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = CacheResult<K, V>>, Route::Sends: SendsFor<User<A, CacheMessage<K, V, Route>>>,

type Protocol = Cache<A, K, V, Route>

Stable public communication identity owned by this actor template.

type Event = User<A, <<Cache<A, K, V, Route> as Behavior>::Protocol as Protocol>::Msg>

type Sends = <Route as DeliveryRoute>::Sends

type Ph = Never

type Error = Never

type Birth = NoBirths

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> BehaviorActed<Self>

Fold exactly one event into explicit actions and the next behavior.

fn init( &mut self, _turn: InitializationTurn, ) -> Result<Actions<<Self::Protocol as Protocol>::Addr, Self::Ph, Self::Sends, Self::Birth>, Self::Error>

where Self: Sized,

Produce initialization actions before the first event is accepted.

fn layer<L>(self, layer: L) -> <L as BehaviorLayer<Self>>::Output

where Self: Sized, L: BehaviorLayer<Self>,

Apply one statically dispatched construction layer.

impl<A, K, V, Route> BehaviorBase for Cache<A, K, V, Route>

where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = CacheResult<K, V>>,

type Base = Cache<A, K, V, Route>

fn base(&self) -> &Self

impl<A, K, V, Route> Protocol for Cache<A, K, V, Route>

where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = CacheResult<K, V>>,

type Addr = A

type Msg = CacheMessage<K, V, Route>