Struct ThreadSafeGenCacheStoreWrapper

pub struct ThreadSafeGenCacheStoreWrapper<'lock, K, V, A, S: ThreadSafeCacheStore<'lock, Key = K, Value = V>, F: Fn(&K, A) -> V + 'lock> {
    pub store: S,
    pub generator: F,
    /* private fields */
}

Infallible thread safe generative cache store wrapper around a ThreadSafeCacheStore and a generator function.

One of the few unafallible thread safe wrappers.

Generics:

• K: Type of the key used for cache indexing.
• V: Type of the value stored in the cache store.
• A: Type of additional arguments of the generator function.
• S: ThreadSafeCacheStore which this wraps around.
• F: Fn<&K, A> with V return generator function.

Fields

store: S

generator: F

Implementations

impl<'lock, K, V, A, S: ThreadSafeCacheStore<'lock, Key = K, Value = V>, F: Fn(&K, A) -> V> ThreadSafeGenCacheStoreWrapper<'lock, K, V, A, S, F>

Default implementation

pub fn new(store: S, generator: F) -> Self

Make a new ThreadSafeGenCacheStoreWrapper from a ThreadSafeCacheStore and a generator function.

Trait Implementations

impl<'lock, K, V, A, S, F: Fn(&K, A) -> V + 'lock> ThreadSafeCacheStore<'lock> for ThreadSafeGenCacheStoreWrapper<'lock, K, V, A, S, F>

where S: ThreadSafeCacheStore<'lock> + ThreadSafeCacheStore<'lock, Key = K, Value = V>,

type Key = <S as ThreadSafeCacheStore<'lock>>::Key

type Value = <S as ThreadSafeCacheStore<'lock>>::Value

type SLock<'guard> = <S as ThreadSafeCacheStore<'lock>>::SLock<'guard> where 'lock: 'guard

Shared lock over a key, must be possible to make one by borrowing a exclusive lock.

type XLock = <S as ThreadSafeCacheStore<'lock>>::XLock

Exclusive lock over a wey.

fn ts_get(&'lock self, handle: &Self::SLock<'_>) -> Option<Self::Value>

Returns an option of the owned cache element if present.

fn ts_set(&'lock self, handle: &mut Self::XLock, value: &Self::Value)

Sets a value given its key.

fn ts_exists(&'lock self, handle: &Self::SLock<'_>) -> bool

Checks if the cache entry exists.

fn ts_one_get(&'lock self, key: &Self::Key) -> Option<Self::Value>

Same as ts_get but it performs a one-time lock

fn ts_one_set(&'lock self, key: &Self::Key, value: &Self::Value)

Same as ts_set but it performs a one-time lock

fn ts_one_exists(&'lock self, key: &Self::Key) -> bool

Same as ts_exists but it performs a one-time lock

fn ts_xlock(&'lock self, key: &Self::Key) -> Self::XLock

Exclusively lock a key until the handle is dropped.

fn ts_slock(&'lock self, key: &Self::Key) -> Self::SLock<'lock>

Acquire a shared lock of a key until the handle is dropped.

fn ts_xlock_nblock(&'lock self, key: &Self::Key) -> Self::XLock

Exclusively lock a key until the handle is dropped. Non blocking.

fn ts_slock_nblock(&'lock self, key: &Self::Key) -> Self::SLock<'lock>

Acquire a shared lock of a key until the handle is dropped. Non blocking.

impl<'lock, K, V: Clone, A, S: ThreadSafeCacheStore<'lock, Key = K, Value = V>, F: Fn(&K, A) -> V> ThreadSafeGenCacheStore<'lock> for ThreadSafeGenCacheStoreWrapper<'lock, K, V, A, S, F>

Implement ThreadSafeCacheStore

type Key = K

type Value = V

type Args = A

fn ts_gen( &'lock self, key: &'lock <Self as ThreadSafeGenCacheStore<'lock>>::Key, args: Self::Args, ) -> <Self as ThreadSafeGenCacheStore<'lock>>::Value

Generate a new value without checking cache or adding the value to it.

fn ts_get_or_gen( &'lock self, key: &'lock <Self as ThreadSafeGenCacheStore<'lock>>::Key, args: Self::Args, ) -> <Self as ThreadSafeGenCacheStore<'lock>>::Value

Get the value from cache or generate a new one without adding it.

fn ts_get_or_new( &'lock self, key: &'lock <Self as ThreadSafeGenCacheStore<'lock>>::Key, args: Self::Args, ) -> <Self as ThreadSafeGenCacheStore<'lock>>::Value

Get the value from cache or generate a new one adding it.

fn ts_gen_new( &'lock self, key: &'lock <Self as ThreadSafeGenCacheStore<'lock>>::Key, args: Self::Args, ) -> <Self as ThreadSafeGenCacheStore<'lock>>::Value

Generate a new value without checking cache and add the value to it, possibly overwriting previous values.