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) -> MemoryCache<A, B>

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>)

Inserts a cache entry into the cache by using a key and a value.

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 cache entry 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));