Struct memory_cache::MemoryCache

pub struct MemoryCache<A, B> { /* fields omitted */ }

Represents a local in-memory cache.

Methods

impl<A: Hash + Eq, B> MemoryCache<A, B>

pub fn new(full_scan_frequency: Duration) -> Self

Creates an empty MemoryCache.

Example

use memory_cache::MemoryCache;
use std::time::Duration;

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);
let cached_value = cache.get(&key);

assert_eq!(cached_value, Some(&value));

pub fn has_key(&self, key: &A) -> bool

Determines whether the MemoryCache<A, B> contains the specified key.

Example

use memory_cache::MemoryCache;
use std::time::Duration;

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);

assert!(cache.has_key(&key));

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

Gets the last scan time.

• None If there were no scans.

Example

use memory_cache::MemoryCache;
use std::time::{Duration, SystemTime};

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);

assert_eq!(cache.get_last_scan_time(), None);

pub fn get_full_scan_frequency(&self) -> &Duration

Gets the full scan frequency.

Example

use memory_cache::MemoryCache;
use std::time::{Duration, SystemTime};

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);

assert_eq!(cache.get_full_scan_frequency(), &scan_frequency);

pub fn get(&self, key: &A) -> Option<&B>

Gets the value associated with the specified key.

Example

use memory_cache::MemoryCache;
use std::time::Duration;

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);

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

pub fn get_or_set<F>(
    &mut self,
    key: A,
    factory: F,
    duration: Option<Duration>
) -> &B where
    F: Fn() -> B, 

Gets the value associated with the specified key, or if the key can not be found, creates and insert value using the factory function.

Example

use memory_cache::MemoryCache;
use std::time::Duration;

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

assert_eq!(cache.get_or_set(key, move || value, None), &value);
assert!(cache.has_key(&key));

pub fn set(&mut self, key: A, value: B, duration: Option<Duration>) -> Option<B>

Inserts a key-value pair into the cache.

If the cache did not have this key present, None is returned.
If the cache did have this key present, the value is updated, and the old value is returned.

Example

use memory_cache::MemoryCache;
use std::time::Duration;

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);

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

pub fn remove(&mut self, key: &A) -> Option<B>

Removes a key from the cache, returning the value at the key if the key was previously in the cache.

Example

use memory_cache::MemoryCache;
use std::time::Duration;

let scan_frequency = Duration::from_secs(60);

let mut cache = MemoryCache::new(scan_frequency);

let key: &'static str = "key";
let value: &'static str = "Hello, World!";

cache.set(key, value, None);

assert_eq!(cache.remove(&key), Some(value));
assert!(!cache.has_key(&key));