Struct MemoryCache 

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

Byte-bounded LRU of inflated entries plus any per-entry state the host wants to keep alongside (T).

Implementations

impl<T> MemoryCache<T>

pub fn new(cap_bytes: usize) -> Self

An empty cache holding at most cap_bytes bytes of entries.

pub fn get(&mut self, key: &ApkKey, entry_name: &str) -> Option<Arc<T>>

The entry cached under entry_name, marked most recently used.

pub fn insert( &mut self, key: &ApkKey, entry_name: &str, value: Arc<T>, size: usize, )

Cache value under entry_name, charged at size bytes, replacing any previous entry and evicting least recently used ones past the capacity.

pub fn recharge( &mut self, key: &ApkKey, entry_name: &str, size_of: impl FnOnce(&T) -> usize, ) -> bool

Re-charge the entry cached under entry_name at size_of its current value, e.g. once per-entry state built after insertion has grown it, and evict least recently used entries if that exceeds the capacity. The value is measured under the cache’s lock, whatever replaced the one a caller last saw, so the charge always matches what the slot holds. Returns whether the charge changed.

pub fn replace( &mut self, key: &ApkKey, entry_name: &str, current: &Arc<T>, new: Arc<T>, ) -> bool

Swap the entry cached under entry_name for new when it is still current, keeping its size and recency. Returns whether it swapped.

pub fn charged_bytes(&self, key: &ApkKey, entry_name: &str) -> Option<usize>

Size the entry cached under entry_name is charged at.

pub fn used_bytes(&self) -> usize

Bytes charged for the cached entries (the reserve not included).

pub fn capacity_bytes(&self) -> usize

Bytes the entries and the reserve may take together.

pub fn reserved_bytes(&self) -> usize

Bytes counted against the capacity besides the entries (MemoryCache::set_reserved).

pub fn set_reserved(&mut self, bytes: usize)

Count bytes the host holds elsewhere against the capacity, evicting least recently used entries to make room.

pub fn set_capacity(&mut self, cap_bytes: usize)

Change the capacity, evicting least recently used entries if the cache now holds more.

pub fn peek(&self, key: &ApkKey, entry_name: &str) -> Option<Arc<T>>

The entry cached under entry_name, without touching its recency.

pub fn values(&self) -> impl Iterator<Item = &Arc<T>>

Every cached value, in no particular order (recency is not touched).

pub fn len(&self) -> usize

Number of cached entries, over every APK.

pub fn is_empty(&self) -> bool

Whether no entry is cached.

pub fn remove_apk(&mut self, key: &ApkKey) -> usize

Drop every entry cached for key and return the bytes released.

pub fn clear(&mut self)

Drop every entry (the reserve is kept).