Struct TryGenCacheStoreWrapper

pub struct TryGenCacheStoreWrapper<K, V, E, A, FnErr: Into<E>, S: TryCacheStore<Key = K, Value = V, Error = E>, F: Fn(&K, A) -> Result<V, FnErr>> {
    pub store: S,
    pub try_generator: F,
    /* private fields */
}

Infallible generative cache store wrapper around a CacheStore and a generator function.

Generics:

• K: Type of the key used for cache indi.
• V: Type of the value stored in the cache store.
• E: Error type used for Results
• A: Type of additional arguments of the generator function.
• FnErr: Error type of the function.
• S: CacheStore which this wraps around.
• F: Fn<&K, A> with V return generator function.

Fields

store: S

try_generator: F

Implementations

impl<K, V, E, A, FnErr: Into<E>, F: Fn(&K, A) -> Result<V, FnErr>, S: TryCacheStore<Key = K, Value = V, Error = E>> TryGenCacheStoreWrapper<K, V, E, A, FnErr, S, F>

Default implementation

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

Make a new TryGenCacheStore from a fallible store and fallible generator function.

Trait Implementations

impl<K, V, E, A, FnErr: Into<E>, S, F: Fn(&K, A) -> Result<V, FnErr>> TryCacheStore for TryGenCacheStoreWrapper<K, V, E, A, FnErr, S, F>

where S: TryCacheStore + TryCacheStore<Key = K, Value = V, Error = E>,

type Key = <S as TryCacheStore>::Key

type Value = <S as TryCacheStore>::Value

type Error = <S as TryCacheStore>::Error

fn try_get( &self, key: impl Borrow<Self::Key>, ) -> Result<Option<Self::Value>, Self::Error>

Attempts to return an option of the owned cache element if present

fn try_set( &mut self, key: impl Borrow<Self::Key>, value: impl Borrow<Self::Value>, ) -> Result<(), Self::Error>

Attempts to set a value given its key.

fn try_exists(&self, key: impl Borrow<Self::Key>) -> Result<bool, Self::Error>

Attempts to check if the cache key entry exists.

impl<K, V, E, A, FnErr: Into<E>, F: Fn(&K, A) -> Result<V, FnErr>, S: TryCacheStore<Key = K, Value = V, Error = E>> TryGenCacheStore for TryGenCacheStoreWrapper<K, V, E, A, FnErr, S, F>

Functions with multiple stages will return the same type of error without any way to detect at what point it failed, and not undoing the changes. If you don’t like this you’ll have to manually follow the steps done by the function and handle the errors yourself.

fn try_gen(&self, key: impl Borrow<K>, args: A) -> Result<V, E>

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

fn try_get_or_gen(&self, key: impl Borrow<K>, args: A) -> Result<V, E>

Attempt to get the value from cache or generate a new one without adding it.

fn try_get_or_new(&mut self, key: impl Borrow<K>, args: A) -> Result<V, E>

Attempt to get the value from cache or generate a new one attempting to add it.

fn try_gen_new(&mut self, key: impl Borrow<K>, args: A) -> Result<V, E>

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

type Key = K

type Value = V

type Error = E

type Args = A