Struct freqache::LFUCache

pub struct LFUCache<K, V, P> { /* fields omitted */ }

A weighted, thread-safe, futures-aware least-frequently-used cache

Implementations

impl<K: Clone + Eq + Hash, V: Entry, P: Policy<K, V>> LFUCache<K, V, P>

pub fn new(capacity: u64, policy: P) -> Self

Construct a new LFUCache.

pub fn contains_key<Q: ?Sized>(&mut self, key: &Q) -> bool where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Return true if the cache contains the given key.

pub async fn get<Q: ?Sized>(
    &mut self,
    key: &Q
) -> Option<impl Deref<Target = impl Deref<Target = V>>> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Borrow the value of the cache entry with the given key.

pub async fn insert(&mut self, key: K, value: V) -> bool

Add a new entry to the cache.

pub fn available(&self) -> u64

Return the unoccupied capacity of this cache.

pub fn capacity(&self) -> u64

Return the capacity of this cache.

pub fn is_empty(&self) -> bool

Return true if the cache is empty.

pub fn is_full(&self) -> bool

Return true if the cache is full.

pub fn len(&self) -> usize

Return the number of entries in this cache.

pub fn occupied(&self) -> u64

Return the currently occupied capacity of this cache.

pub async fn remove<Q>(&mut self, key: &Q) -> Option<V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Remove an entry from the cache, and clone and return its value if present.

pub async fn traverse<C: FnMut(&V) + Send>(&self, f: C)

Traverse the cache values beginning with the least-frequent.

pub async fn evict(&mut self) where
    K: Debug, 

Traverse the cache entries beginning with the least-frequent, and evict entries from the cache according to this its Policy.