Struct MemoryCache 

pub struct MemoryCache { /* private fields */ }

In-memory cache with TTL support

This cache stores values in memory using a HashMap with optional time-to-live (TTL) for entries. It’s suitable for single-process applications or as a fallback cache.

Example

use allframe_core::cache::{Cache, MemoryCache, CacheConfig};
use std::time::Duration;

let cache = MemoryCache::with_config(
    CacheConfig::new()
        .prefix("myapp")
        .default_ttl(Duration::from_secs(300))
);

cache.set("key", &"value", None).await;
let value: Option<String> = cache.get("key").await;

Implementations

impl MemoryCache

pub fn new() -> Self

Create a new memory cache with default configuration

pub fn with_config(config: CacheConfig) -> Self

Create a new memory cache with custom configuration

pub fn builder() -> MemoryCacheBuilder

Create a builder for the memory cache

pub fn cleanup_expired(&self)

Remove expired entries from the cache

This is called automatically on get operations, but can be called manually if needed.

Trait Implementations

impl Cache for MemoryCache

fn get<T: DeserializeOwned + Send>( &self, key: &str, ) -> Pin<Box<dyn Future<Output = Option<T>> + Send + '_>>

Get a value from the cache

fn set<T: Serialize + Send + Sync>( &self, key: &str, value: &T, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>

Set a value in the cache with an optional TTL

fn delete(&self, key: &str) -> Pin<Box<dyn Future<Output = bool> + Send + '_>>

Delete a value from the cache

fn exists(&self, key: &str) -> Pin<Box<dyn Future<Output = bool> + Send + '_>>

Check if a key exists in the cache

fn clear(&self) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>

Clear all entries from the cache

fn len(&self) -> Pin<Box<dyn Future<Output = Option<usize>> + Send + '_>>

Get the number of entries in the cache (if supported)

fn get_many<T: DeserializeOwned + Send>( &self, keys: &[&str], ) -> Pin<Box<dyn Future<Output = Vec<Option<T>>> + Send + '_>>

Get multiple values from the cache

fn set_many<'a, T: Serialize + Send + Sync + 'a>( &'a self, entries: Vec<(String, T)>, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>

Set multiple values in the cache

fn delete_many( &self, keys: &[&str], ) -> Pin<Box<dyn Future<Output = usize> + Send + '_>>

Delete multiple keys from the cache

fn is_empty(&self) -> Pin<Box<dyn Future<Output = bool> + Send + '_>>

Check if the cache is empty

impl Default for MemoryCache

fn default() -> Self

Returns the “default value” for a type.