Struct dyn_cache::local::SharedLocalCache [−][src]
pub struct SharedLocalCache { /* fields omitted */ }
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
[src]
impl SharedLocalCache
[src]pub fn cache_with<Key: ?Sized, Scope, Arg: ?Sized, 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>,
Scope: 'static + Borrow<Key> + Eq + Hash,
Arg: PartialEq<Input> + ToOwned<Owned = Input>,
Input: 'static + Borrow<Arg>,
Output: 'static,
Ret: 'static,
[src]
&self,
key: &Key,
arg: &Arg,
init: impl FnOnce(&Input) -> Output,
with: impl FnOnce(&Output) -> Ret
) -> Ret where
Key: Eq + Hash + ToOwned<Owned = Scope>,
Scope: 'static + Borrow<Key> + Eq + Hash,
Arg: PartialEq<Input> + ToOwned<Owned = Input>,
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: ?Sized, Scope, Arg: ?Sized, Input, Output>(
&self,
key: &Key,
arg: &Arg,
init: impl FnOnce(&Input) -> Output
) -> Output where
Key: Eq + Hash + ToOwned<Owned = Scope>,
Scope: 'static + Borrow<Key> + Eq + Hash,
Arg: PartialEq<Input> + ToOwned<Owned = Input>,
Input: 'static + Borrow<Arg>,
Output: 'static + Clone,
[src]
&self,
key: &Key,
arg: &Arg,
init: impl FnOnce(&Input) -> Output
) -> Output where
Key: Eq + Hash + ToOwned<Owned = Scope>,
Scope: 'static + Borrow<Key> + Eq + Hash,
Arg: PartialEq<Input> + ToOwned<Owned = Input>,
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: ?Sized, Scope, Arg: ?Sized, Input, Output>(
&self,
key: &Key,
arg: &Arg,
init: impl FnOnce(&Input) -> Output
) where
Key: Eq + Hash + ToOwned<Owned = Scope>,
Scope: 'static + Borrow<Key> + Eq + Hash,
Arg: PartialEq<Input> + ToOwned<Owned = Input>,
Input: 'static + Borrow<Arg>,
Output: 'static,
[src]
&self,
key: &Key,
arg: &Arg,
init: impl FnOnce(&Input) -> Output
) where
Key: Eq + Hash + ToOwned<Owned = Scope>,
Scope: 'static + Borrow<Key> + Eq + Hash,
Arg: PartialEq<Input> + ToOwned<Owned = Input>,
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)
[src]
Forwards to LocalCache::gc
.
Trait Implementations
impl Clone for SharedLocalCache
[src]
impl Clone for SharedLocalCache
[src]fn clone(&self) -> SharedLocalCache
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Default for SharedLocalCache
[src]
impl Default for SharedLocalCache
[src]fn default() -> SharedLocalCache
[src]
impl Eq for SharedLocalCache
[src]
impl Eq for SharedLocalCache
[src]impl From<LocalCache> for SharedLocalCache
[src]
impl From<LocalCache> for SharedLocalCache
[src]fn from(inner: LocalCache) -> Self
[src]
impl Hash for SharedLocalCache
[src]
impl Hash for SharedLocalCache
[src]impl Ord for SharedLocalCache
[src]
impl Ord for SharedLocalCache
[src]impl PartialEq<SharedLocalCache> for SharedLocalCache
[src]
impl PartialEq<SharedLocalCache> for SharedLocalCache
[src]impl PartialOrd<SharedLocalCache> for SharedLocalCache
[src]
impl PartialOrd<SharedLocalCache> for SharedLocalCache
[src]impl RefUnwindSafe for SharedLocalCache
[src]
impl RefUnwindSafe for SharedLocalCache
[src]impl UnwindSafe for SharedLocalCache
[src]
impl UnwindSafe for SharedLocalCache
[src]Auto Trait Implementations
Blanket Implementations
impl<T> DowncastSync for T where
T: Any + Send + Sync,
[src]
impl<T> DowncastSync for T where
T: Any + Send + Sync,
[src]