Struct PrefixedCache 

pub struct PrefixedCache { /* private fields */ }

Prefixes every key, so several applications can share one cache server.

Worth reaching for whenever the cache is not exclusively yours. Two applications caching user:1 on one Redis database will read each other’s values — and the symptom is a user seeing another application’s data, not a crash.

It also makes flush safe to mean “mine”: the inner cache’s flush would empty the whole database, including the other application’s keys and anybody’s sessions.

let shared: Arc<dyn Cache> = Arc::new(MemoryCache::new());

let billing = PrefixedCache::new(Arc::clone(&shared), "billing");
let catalogue = PrefixedCache::new(Arc::clone(&shared), "catalogue");

billing.put_string("total", "10", None).await?;
catalogue.put_string("total", "999", None).await?;

assert_eq!(billing.get_string("total").await?.as_deref(), Some("10"));

Implementations

impl PrefixedCache

pub fn new(inner: Arc<dyn Cache>, prefix: impl Into<String>) -> Self

Wrap inner, prefixing every key with prefix:.

pub fn prefix(&self) -> &str

The prefix, without its separator.

pub fn inner(&self) -> &Arc<dyn Cache>

The cache underneath.

Trait Implementations

impl Cache for PrefixedCache

fn flush(&self) -> BoxFuture<'_, Result<()>>

Not implemented as a flush.

There is no portable way to delete by prefix: Redis needs a SCAN loop and Memcached cannot do it at all. Delegating to the inner flush would empty the whole server, which is precisely what wrapping it was meant to prevent — so this refuses instead of doing something surprising.

fn name(&self) -> &str

A label for diagnostics — "memory", "redis", "memcached".

fn is_shared(&self) -> bool

Whether this store is visible to other processes.

fn get<'a>(&'a self, key: &'a str) -> BoxFuture<'a, Result<Option<Vec<u8>>>>

The value at key, or None if it is absent or expired.

fn put<'a>( &'a self, key: &'a str, value: &'a [u8], ttl: Option<Duration>, ) -> BoxFuture<'a, Result<()>>

Store value, expiring after ttl. None means no expiry.

fn forget<'a>(&'a self, key: &'a str) -> BoxFuture<'a, Result<bool>>

Remove a key. true if it was there.

fn increment<'a>(&'a self, key: &'a str, by: i64) -> BoxFuture<'a, Result<i64>>

Add by to a counter, creating it at zero first. Returns the new value.

fn add<'a>( &'a self, key: &'a str, value: &'a [u8], ttl: Option<Duration>, ) -> BoxFuture<'a, Result<bool>>

Store value only if key is absent. true if it was stored.

fn forget_if<'a>( &'a self, key: &'a str, expected: &'a [u8], ) -> BoxFuture<'a, Result<bool>>

Remove key only if it currently holds expected. true if it was removed.

fn has<'a>(&'a self, key: &'a str) -> BoxFuture<'a, Result<bool>>

Whether a key is present and unexpired.

fn supports_atomic_add(&self) -> bool

Whether add is genuinely atomic here.

impl Debug for PrefixedCache

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

Formats the value using the given formatter.