Struct cache_loader_async::cache_api::LoadingCache

pub struct LoadingCache<K, V> { /* fields omitted */ }

Implementations

impl<K: Eq + Hash + Clone + Send + 'static, V: Clone + Sized + Send + 'static> LoadingCache<K, V>

pub fn new<T, F>(loader: T) -> (LoadingCache<K, V>, CacheHandle) where
    F: Future<Output = Option<V>> + Sized + Send + 'static,
    T: Fn(K) -> F + Send + 'static, 

Creates a new instance of a LoadingCache

Arguments

• loader - A function which returns a Future<Output=Option>

Return Value

This method returns a tuple, with: 0 - The instance of the LoadingCache 1 - The CacheHandle which is a JoinHandle<()> and represents the task which operates the cache

Examples

    use cache_loader_async::cache_api::LoadingCache;
    use std::collections::HashMap;
    let static_db: HashMap<String, u32> =
        vec![("foo".into(), 32), ("bar".into(), 64)]
            .into_iter()
            .collect();

    let (cache, _) = LoadingCache::new(move |key: String| {
        let db_clone = static_db.clone();
        async move {
            db_clone.get(&key).cloned()
        }
    });

    let result = cache.get("foo".to_owned()).await.unwrap();

    assert_eq!(result, 32);

pub async fn get(&self, key: K) -> Result<V, CacheLoadingError>

Retrieves or loads the value for specified key from either cache or loader function

Arguments

• key - The key which should be loaded

Return Value

Returns a Result with: Ok - Value of type V Err - Error of type CacheLoadingError

pub async fn set(
    &self,
    key: K,
    value: V
) -> Result<Option<V>, CacheLoadingError>

Sets the value for specified key and bypasses eventual currently ongoing loads If a key has been set programmatically, eventual concurrent loads will not change the value of the key.

Arguments

• key - The key which should be loaded

Return Value

Returns a Result with: Ok - Previous value of type V wrapped in an Option depending whether there was a previous value Err - Error of type CacheLoadingError

pub async fn update<U>(
    &self,
    key: K,
    update_fn: U
) -> Result<V, CacheLoadingError> where
    U: FnOnce(V) -> V + Send + 'static, 

Unstable, Undocumented & Inconsistent. Don’t use that just yet

Trait Implementations

impl<K: Clone, V: Clone> Clone for LoadingCache<K, V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for LoadingCache<K, V>

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

Formats the value using the given formatter.