Enum Cache 

pub enum Cache<K, V, S = DefaultHasher, P = CacheProperties>
where
    K: Key,
    V: Value,
    S: HashBuilder,
    P: Properties,
{
    Fifo(Arc<RawCache<Fifo<K, V, P>, S>>),
    Lru(Arc<RawCache<Lru<K, V, P>, S>>),
    Lfu(Arc<RawCache<Lfu<K, V, P>, S>>),
    S3Fifo(Arc<RawCache<S3Fifo<K, V, P>, S>>),
    Sieve(Arc<RawCache<Sieve<K, V, P>, S>>),
}

In-memory cache with plug-and-play algorithms.

Variants

Fifo(Arc<RawCache<Fifo<K, V, P>, S>>)

In-memory FIFO cache.

Lru(Arc<RawCache<Lru<K, V, P>, S>>)

In-memory LRU cache.

Lfu(Arc<RawCache<Lfu<K, V, P>, S>>)

In-memory LFU cache.

S3Fifo(Arc<RawCache<S3Fifo<K, V, P>, S>>)

In-memory S3FIFO cache.

Sieve(Arc<RawCache<Sieve<K, V, P>, S>>)

In-memory Sieve cache.

Implementations

impl<K, V> Cache<K, V, DefaultHasher, CacheProperties>

where K: Key, V: Value,

pub fn builder(capacity: usize) -> CacheBuilder<K, V, DefaultHasher>

Create a new in-memory cache builder with capacity.

impl<K, V, S, P> Cache<K, V, S, P>

where K: Key, V: Value, S: HashBuilder, P: Properties,

pub fn resize(&self, capacity: usize) -> Result<()>

Update capacity and evict overflowed entries.

pub fn insert(&self, key: K, value: V) -> CacheEntry<K, V, S, P>

Insert cache entry to the in-memory cache.

pub fn insert_with_properties( &self, key: K, value: V, properties: P, ) -> CacheEntry<K, V, S, P>

Insert cache entry to the in-memory cache with properties.

pub fn remove<Q>(&self, key: &Q) -> Option<CacheEntry<K, V, S, P>>

where Q: Hash + Equivalent<K> + ?Sized,

Remove a cached entry with the given key from the in-memory cache.

pub fn get<Q>(&self, key: &Q) -> Option<CacheEntry<K, V, S, P>>

where Q: Hash + Equivalent<K> + ?Sized,

Get cached entry with the given key from the in-memory cache.

pub fn contains<Q>(&self, key: &Q) -> bool

where Q: Hash + Equivalent<K> + ?Sized,

Check if the in-memory cache contains a cached entry with the given key.

pub fn touch<Q>(&self, key: &Q) -> bool

where Q: Hash + Equivalent<K> + ?Sized,

Access the cached entry with the given key but don’t return.

Note: This method can be used to update the cache eviction information and order based on the algorithm.

pub fn clear(&self)

Clear the in-memory cache.

pub fn capacity(&self) -> usize

Get the capacity of the in-memory cache.

pub fn usage(&self) -> usize

Get the usage of the in-memory cache.

pub fn hash<Q>(&self, key: &Q) -> u64

where Q: Hash + ?Sized,

Hash the given key with the hash builder of the cache.

pub fn hash_builder(&self) -> &Arc<S>

Get the hash builder of the in-memory cache.

pub fn shards(&self) -> usize

Get the shards of the in-memory cache.

pub fn evict_all(&self)

Evict all entries from the in-memory cache.

Instead of Cache::clear, Cache::evict_all will send the evicted pipe to the pipe. It is useful when the cache is used as a hybrid cache.

pub async fn flush(&self)

Evict all entries in the cache and offload them into the disk cache via the pipe if needed.

This function obeys the io throttler of the disk cache and make sure all entries will be offloaded. Therefore, this function is asynchronous.

impl<K, V, S, P> Cache<K, V, S, P>

where K: Key + Clone, V: Value, S: HashBuilder, P: Properties,

pub fn fetch<F, FU, ER>(&self, key: K, fetch: F) -> Fetch<K, V, ER, S, P>

where F: FnOnce() -> FU, FU: Future<Output = Result<V, ER>> + Send + 'static, ER: Send + 'static + Debug,

Get the cached entry with the given key from the in-memory cache.

Use fetch to fetch the cache value from the remote storage on cache miss.

The concurrent fetch requests will be deduplicated.

pub fn fetch_with_properties<F, FU, ER>( &self, key: K, properties: P, fetch: F, ) -> Fetch<K, V, ER, S, P>

where F: FnOnce() -> FU, FU: Future<Output = Result<V, ER>> + Send + 'static, ER: Send + 'static + Debug,

Get the cached entry with the given key and properties from the in-memory cache.

Use fetch to fetch the cache value from the remote storage on cache miss.

The concurrent fetch requests will be deduplicated.

Trait Implementations

impl<K, V, S, P> Clone for Cache<K, V, S, P>

where K: Key, V: Value, S: HashBuilder, P: Properties,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, S, P> Debug for Cache<K, V, S, P>

where K: Key, V: Value, S: HashBuilder, P: Properties,

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

Formats the value using the given formatter.