Struct InMemoryCache 

pub struct InMemoryCache<K, V, H = RandomState>
where
    K: Hash + Eq + Send + Sync + 'static,
    V: Clone + Send + Sync + 'static,
    H: BuildHasher + Clone + Send + Sync + 'static,
{ /* private fields */ }

Available on crate features memory only.

A concurrent in-memory cache tier.

This cache provides:

• Concurrent access with high performance
• Automatic eviction based on capacity
• Thread-safe operations

Examples

use cachet_memory::InMemoryCache;
use cachet_tier::{CacheEntry, CacheTier};


let cache = InMemoryCache::<String, i32>::new();

cache
    .insert("key".to_string(), CacheEntry::new(42))
    .await
    .unwrap();
let value = cache.get(&"key".to_string()).await.unwrap();
assert_eq!(*value.unwrap().value(), 42);

Implementations

impl<K, V> InMemoryCache<K, V>

where K: Hash + Eq + Send + Sync + 'static, V: Clone + Send + Sync + 'static,

pub fn new() -> InMemoryCache<K, V>

Creates a new unbounded in-memory cache.

The cache will use default eviction policy (TinyLFU).

Examples

use cachet_memory::InMemoryCache;

let cache = InMemoryCache::<String, i32>::new();

pub fn with_max_capacity(max_capacity: u64) -> InMemoryCache<K, V>

Creates a new in-memory cache with a maximum capacity.

Once the capacity is reached, entries will be evicted using the TinyLFU policy (combination of LRU eviction and LFU admission).

Examples

use cachet_memory::InMemoryCache;

let cache = InMemoryCache::<String, i32>::with_max_capacity(1000);

pub fn builder() -> InMemoryCacheBuilder<K, V>

Creates a new builder for configuring an in-memory cache.

The builder provides access to additional configuration options such as time-to-live, time-to-idle, and initial capacity.

Examples

use std::time::Duration;

use cachet_memory::InMemoryCache;

let cache = InMemoryCache::<String, i32>::builder()
    .max_capacity(1000)
    .time_to_live(Duration::from_secs(300))
    .time_to_idle(Duration::from_secs(60))
    .build();

Trait Implementations

impl<K, V, H> CacheTier<K, V> for InMemoryCache<K, V, H>

where K: Clone + Hash + Eq + Send + Sync + 'static, V: Clone + Send + Sync + 'static, H: BuildHasher + Clone + Send + Sync + 'static,

async fn get(&self, key: &K) -> Result<Option<CacheEntry<V>>, Error>

Gets a value, returning an error if the operation fails.

async fn insert(&self, key: K, entry: CacheEntry<V>) -> Result<(), Error>

Inserts or replaces a value, returning an error if the operation fails.

async fn invalidate(&self, key: &K) -> Result<(), Error>

Invalidates a value, returning an error if the operation fails.

async fn clear(&self) -> Result<(), Error>

Clears all entries, returning an error if the operation fails.

async fn len(&self) -> Result<u64, SizeError>

Returns an approximate count of entries, if the implementation supports it.

fn is_empty(&self) -> impl Future<Output = Result<bool, SizeError>> + Send

Returns Ok(true) if the cache appears to contain no entries.

impl<K, V, H> Clone for InMemoryCache<K, V, H>

where K: Clone + Hash + Eq + Send + Sync + 'static, V: Clone + Send + Sync + 'static, H: Clone + BuildHasher + Send + Sync + 'static,

fn clone(&self) -> InMemoryCache<K, V, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, H> Debug for InMemoryCache<K, V, H>

where K: Debug + Hash + Eq + Send + Sync + 'static, V: Debug + Clone + Send + Sync + 'static, H: Debug + BuildHasher + Clone + Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<K, V> Default for InMemoryCache<K, V>

where K: Hash + Eq + Send + Sync + 'static, V: Clone + Send + Sync + 'static,

fn default() -> InMemoryCache<K, V>

Returns the “default value” for a type.

impl<K, V, H> ThreadAware for InMemoryCache<K, V, H>

where K: ThreadAware + Hash + Eq + Send + Sync + 'static, V: ThreadAware + Clone + Send + Sync + 'static, H: ThreadAware + BuildHasher + Clone + Send + Sync + 'static,

fn relocate(&mut self, source: Option<Affinity>, destination: Affinity)

Relocate this value in place to the destination affinity.