Struct high_mem_utils::LazyCache

pub struct LazyCache<P: Ord, V: Clone, C: Fn(P) -> V> {
    pub closure: C,
    // some fields omitted
}

A lazy-iniatialiazed cache for a Fn closure with a constant constructor.

Fields

closure: C

Methods

impl<P: Ord + Clone, V: Clone, C: Fn(P) -> V> LazyCache<P, V, C>

pub const fn new(closure: C) -> Self

Construct a cache for a closure that is initialized in the first call to call_cache.

This is particularly useful for fn pointers of recurrently used functions because it can be used on statics,althought you need make them mutable for actually call call_cache.

pub const fn with_cache(cache: BTreeMap<P, V>, closure: C) -> Self

Construct a cache for a closure providing an iniatialized cache.

pub const unsafe fn with_cache_unchecked(
    cache: MaybeUninit<BTreeMap<P, V>>,
    closure: C,
    init: bool
) -> Self

Cosntruct a cache for a closure providing a maybe unininitialized one along with the init state.

If you do know that init is true the with_cache is preferred.

Safety

This function is unsafe due to being unable to prove that the init value is correct and true only for initialiazed caches.

Considering that a bad use can lead to try to read or destruct uninitializated memory the use of this function is discouraged and it only exist to give flexibility while maintaining the fields private.

pub fn call_cache(&mut self, arg: P) -> V

Calls the inner closure with the given arg,after initializing the cache if it did not before.

Examples

use high_mem_utils::LazyCache;
 
fn foo(num: u32) -> u32 {
    num
}
 
let mut cache = LazyCache::new(foo);
 
assert_eq!(cache.call_cache(2), 2);
assert_eq!(cache.call_cache(2), 2);
assert_eq!(cache.call_cache(4), 4);

pub fn pop(&mut self, arg: &P) -> Option<V>

This method removes an argument from the cache and returns the value or None if there's no one or the cache is uninitialized.

Examples

use high_mem_utils::LazyCache;
 
fn foo(num: u32) -> u32 {
    num
}
 
let mut cache = LazyCache::new(foo);
 
assert_eq!(cache.call_cache(2), 2);
assert_eq!(cache.pop(&2), Some(2));
assert_eq!(cache.pop(&2), None);

pub fn clear(&mut self)

Clears the cache,removing all their values.This is no-op if the cache is not initialized.

pub fn is_init(&self) -> bool

Returns true if the cache is initialized,not neccesarily filled with an argument. Use !is_empty for that purpose.

pub fn is_empty(&self) -> bool

Returns true if the cache has no arguments or if it's not initialized.

pub fn cache<F: Fn(&mut BTreeMap<P, V>)>(&mut self, f: F)

This method calls a closure that receives a mutable reference to the cache,allowing using methods provided by BTreeMap.

Examples

use high_mem_utils::LazyCache;
 
let mut cache = LazyCache::new(|x| x);
 
cache.cache(|c| {c.insert(2, 2);});
assert_eq!(cache.pop(&2), Some(2));
assert_eq!(cache.call_cache(2), 2);
assert_eq!(cache.pop(&2), Some(2));
assert_eq!(cache.pop(&2), None);

Trait Implementations

impl<P: Ord, V: Clone, C: Fn(P) -> V> Drop for LazyCache<P, V, C>

This impl drops the cache only if it's initialiazed.

fn drop(&mut self)

Executes the destructor for this type.