Struct SharedLocalCache 

pub struct SharedLocalCache { /* private fields */ }

Provides shared, synchronized access to a LocalCache and a function-memoization API in SharedLocalCache::cache_with.

For convenience wrappers around SharedLocalCache::cache_with see SharedLocalCache::cache for returned types that implement Clone and SharedLocalCache::hold for values that just need to be stored without returning a reference.

Example

let storage = dyn_cache::local::SharedLocalCache::default();
let call_count = std::cell::Cell::new(0);
let increment_count = |&to_add: &i32| {
    let new_count = call_count.get() + to_add;
    call_count.set(new_count);
    new_count
};

assert_eq!(call_count.get(), 0, "not called yet");

let with_one = storage.cache_with(&'a', &1, &increment_count, Clone::clone);
assert_eq!(call_count.get(), 1, "called only once");
assert_eq!(call_count.get(), with_one);

let with_one_again = storage.cache_with(&'a', &1, &increment_count, Clone::clone);
assert_eq!(call_count.get(), 1, "still called only once, previous value cached");
assert_eq!(call_count.get(), with_one_again);

let with_two = storage.cache_with(&'a', &2, &increment_count, Clone::clone);
assert_eq!(call_count.get(), 3, "called again with a new, larger increment");
assert_eq!(call_count.get(), with_two);

let with_other_query = storage.cache_with(&'b', &1, &increment_count, Clone::clone);
assert_eq!(call_count.get(), 4, "called again with the same increment, different scope");
assert_eq!(call_count.get(), with_other_query);

let with_two_again = storage.cache_with(&'a', &2, &increment_count, Clone::clone);
assert_eq!(call_count.get(), 4, "cell still has last mutation's value");
assert_eq!(with_two_again, with_two, "cache should still have previous value");

storage.gc(); // won't drop any values, but sets all of the cached values to be dropped
call_count.set(0);

// re-run 'b', marking it live
let reran_other_query = storage.cache_with(&'b', &1, &increment_count, Clone::clone);
assert_eq!(reran_other_query , 4, "returns the cached value");
assert_eq!(call_count.get(), 0, "without running increment_count");

storage.gc(); // query 'a' will be dropped

// re-run 'b', observing cached value
let reran_other_query = storage.cache_with(&'b', &1, &increment_count, Clone::clone);
assert_eq!(reran_other_query , 4, "still returns the cached value");
assert_eq!(call_count.get(), 0, "still without running increment_count");

// run 'a' again, observe no cached value
let with_one_again = storage.cache_with(&'a', &1, &increment_count, Clone::clone);
assert_eq!(call_count.get(), 1, "called without caching");
assert_eq!(call_count.get(), with_one_again);

Implementations

impl SharedLocalCache

pub fn cache_with<Key, Scope, Arg, Input, Output, Ret>( &self, key: &Key, arg: &Arg, init: impl FnOnce(&Input) -> Output, with: impl FnOnce(&Output) -> Ret, ) -> Ret

where Key: Eq + Hash + ToOwned<Owned = Scope> + ?Sized, Scope: 'static + Borrow<Key> + Eq + Hash, Arg: PartialEq<Input> + ToOwned<Owned = Input> + ?Sized, Input: 'static + Borrow<Arg>, Output: 'static, Ret: 'static,

Caches the result of init(arg) once per key, re-running it when arg changes. Always runs with on the stored Output before returning the result.

See SharedLocalCache::cache for an ergonomic wrapper that requires Output: Clone.

pub fn cache<Key, Scope, Arg, Input, Output>( &self, key: &Key, arg: &Arg, init: impl FnOnce(&Input) -> Output, ) -> Output

where Key: Eq + Hash + ToOwned<Owned = Scope> + ?Sized, Scope: 'static + Borrow<Key> + Eq + Hash, Arg: PartialEq<Input> + ToOwned<Owned = Input> + ?Sized, Input: 'static + Borrow<Arg>, Output: 'static + Clone,

Caches the result of init(arg) once per key, re-running it when arg changes. Clones the cached output before returning the result.

See SharedLocalCache::cache_with for a lower-level version which does not require Output: Clone.

pub fn hold<Key, Scope, Arg, Input, Output>( &self, key: &Key, arg: &Arg, init: impl FnOnce(&Input) -> Output, )

where Key: Eq + Hash + ToOwned<Owned = Scope> + ?Sized, Scope: 'static + Borrow<Key> + Eq + Hash, Arg: PartialEq<Input> + ToOwned<Owned = Input> + ?Sized, Input: 'static + Borrow<Arg>, Output: 'static,

Caches the result of init(arg) once per key, re-running it when arg changes.

Does not return any reference to the cached value. See SharedLocalCache::cache for similar functionality that returns a copy of Output or SharedLocalCache::cache_with which allows specifying other pre-return functions.

pub fn gc(&self)

Forwards to LocalCache::gc.

Trait Implementations

impl Clone for SharedLocalCache

fn clone(&self) -> SharedLocalCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SharedLocalCache

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

Formats the value using the given formatter.

impl Default for SharedLocalCache

fn default() -> SharedLocalCache

Returns the “default value” for a type.

impl From<LocalCache> for SharedLocalCache

fn from(inner: LocalCache) -> Self

Converts to this type from the input type.

impl Hash for SharedLocalCache

fn hash<H>(&self, hasher: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for SharedLocalCache

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SharedLocalCache

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for SharedLocalCache

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for SharedLocalCache

impl RefUnwindSafe for SharedLocalCache

impl UnwindSafe for SharedLocalCache