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 fn call_cache(&mut self, arg: P) -> V

calls the inner closure with the givem arg after init the cache if it did not before.

Panics

If the given closure panic the variable reading them from the MaybeUninit is guranteed to not drop and the Drop impl will do the job.

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 for that purporse.

pub fn is_empty(&self) -> bool

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

Trait Implementations

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

fn drop(&mut self)

Executes the destructor for this type.