Struct engine::store::Cache

pub struct Cache<K, V> where
    K: Hash + Eq,
    V: Clone + Debug,  { /* fields omitted */ }

The cache struct used to store the data in an ordered format.

Implementations

impl<K: Hash + Eq, V: Clone + Debug> Cache<K, V>

pub fn new() -> Self

creates a new empty Cache

Example

use engine::store::Cache;
use std::time::Duration;

let mut cache = Cache::new();

let key: Vec<u8> = b"key".to_vec();
let value: Vec<u8> = b"value".to_vec();

cache.insert(key.clone(), value.clone(), None);

assert_eq!(cache.get(&key), Some(&value))

pub fn create_with_scanner(scan_freq: Duration) -> Self

creates an empty Cache with a periodic scanner which identifies expired entries.

Example

use engine::store::Cache;
use std::time::Duration;

let scan_freq = Duration::from_secs(60);

let mut cache = Cache::create_with_scanner(scan_freq);

let key: &'static str = "key";
let value: &'static str = "value";

cache.insert(key, value, None);

assert_eq!(cache.get(&key), Some(&value));

pub fn get(&self, key: &K) -> Option<&V>

Gets the value associated with the specified key.

Example

use engine::store::Cache;
use std::time::Duration;

let mut cache = Cache::new();

let key: &'static str = "key";
let value: &'static str = "value";

cache.insert(key, value, None);

assert_eq!(cache.get(&key), Some(&value))

pub fn get_or_insert<F>(
    &mut self,
    key: K,
    func: F,
    lifetime: Option<Duration>
) -> &V where
    F: Fn() -> V, 

Gets the value associated with the specified key. If the key could not be found in the Cache, creates and inserts the value using a specified func function. # Example

use engine::store::Cache;
use std::time::Duration;

let mut cache = Cache::new();

let key = "key";
let value = "value";

assert_eq!(cache.get_or_insert(key, move || value, None), &value);
assert!(cache.contains_key(&key));

pub fn insert(
    &mut self,
    key: K,
    value: V,
    lifetime: Option<Duration>
) -> Option<V>

Insert a key-value pair into the cache. If key was not present, a None is returned, else the value is updated and the old value is returned.

Example

use engine::store::Cache;
use std::time::Duration;

let mut cache = Cache::new();

let key: &'static str = "key";
let value: &'static str = "value";

let insert = cache.insert(key, value, None);

assert_eq!(cache.get(&key), Some(&value));
assert!(insert.is_none());

pub fn remove(&mut self, key: &K) -> Option<V>

Removes a key from the cache. Returns the value from the key if the key existed in the cache.

Example

use engine::store::Cache;
use std::time::Duration;

let mut cache = Cache::new();

let key: &'static str = "key";
let value: &'static str = "value";

let insert = cache.insert(key, value, None);
assert_eq!(cache.remove(&key), Some(value));
assert!(!cache.contains_key(&key));

pub fn contains_key(&self, key: &K) -> bool

pub fn get_last_scanned_at(&self) -> Option<SystemTime>

pub fn get_scan_freq(&self) -> Option<Duration>

Get the cache’s scan frequency.

Example

use engine::store::Cache;
use std::time::Duration;

let scan_freq = Duration::from_secs(60);

let mut cache = Cache::create_with_scanner(scan_freq);

let key: &'static str = "key";
let value: &'static str = "value";

cache.insert(key, value, None);

assert_eq!(cache.get_scan_freq(), Some(scan_freq));

pub fn clear(&mut self)

Clear the stored cache and reset.

Trait Implementations

impl<K: Clone, V: Clone> Clone for Cache<K, V> where
    K: Hash + Eq,
    V: Clone + Debug, 

fn clone(&self) -> Cache<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 Cache<K, V> where
    K: Hash + Eq,
    V: Clone + Debug, 

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

Formats the value using the given formatter.

impl<K: Hash + Eq, V: Clone + Debug> Default for Cache<K, V>

Default implementation for Cache<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for Cache<K, V> where
    K: Hash + Eq,
    V: Clone + Debug,
    K: Deserialize<'de>,
    V: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<K, V> Serialize for Cache<K, V> where
    K: Hash + Eq,
    V: Clone + Debug,
    K: Serialize,
    V: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.