[][src]Struct aba_cache::LruCache

pub struct LruCache<K, V> { /* fields omitted */ }

Cache with LRU eviction strategy

Methods

impl<K: Hash + Eq, V> Cache<K, V>[src]

pub fn new(multiply_cap: usize, timeout_secs: u64) -> Self[src]

Create new Cache, which will expiring its entry after timeout_secs and allocating new slab with capacity multiply_cap when no space is ready and no entry expires

pub fn get<Q: ?Sized>(&mut self, key: &Q) -> Option<&V> where
    Arc<K>: Borrow<Q>,
    Q: Hash + Eq
[src]

Returns a reference to the value of the key in the cache or None if it is not present in the cache. Moves the key to the head of the LRU list if it exists.

Example

use aba_cache as cache;
use cache::LruCache;

let mut cache = LruCache::new(2, 60);

cache.put(1, "a");
cache.put(2, "b");
cache.put(2, "c");
cache.put(3, "d");

assert_eq!(cache.get(&1), Some(&"a"));
assert_eq!(cache.get(&2), Some(&"c"));
assert_eq!(cache.get(&3), Some(&"d"));

pub fn put(&mut self, key: K, value: V) -> Option<V>[src]

Puts a key-value pair into cache. If the key already exists in the cache, then it updates the key's value and returns the old value. Otherwise, None is returned.

Example

use aba_cache as cache;
use cache::LruCache;

let mut cache = LruCache::new(2, 60);

assert_eq!(None, cache.put(1, "a"));
assert_eq!(None, cache.put(2, "b"));
assert_eq!(Some("b"), cache.put(2, "beta"));

assert_eq!(cache.get(&1), Some(&"a"));
assert_eq!(cache.get(&2), Some(&"beta"));

pub fn evict(&mut self)[src]

Removes expired entry. This operation will deallocate empty slab caused by entry removal if any.

Example

use aba_cache as cache;
use cache::LruCache;
use std::{thread, time::Duration};

let mut cache = LruCache::new(2, 1);

cache.put(String::from("1"), "one");
cache.put(String::from("2"), "two");
cache.put(String::from("3"), "three");

assert_eq!(cache.len(), 3);
assert_eq!(cache.capacity(), 4);

thread::sleep(Duration::from_secs(1));
cache.evict();

assert_eq!(cache.len(), 0);
assert_eq!(cache.capacity(), 0);

pub fn capacity(&self) -> usize[src]

Returns the maximum number of key-value pairs the cache can hold. Note that on data insertion, when no space is available and no entry is timeout, then capacity will be added with multiply_cap to accomodate.

Example

use aba_cache as cache;
use cache::LruCache;

let mut cache: LruCache<usize, &str> = LruCache::new(2, 60);
assert_eq!(cache.capacity(), 2);

cache.put(1, "a");
assert_eq!(cache.capacity(), 2);

cache.put(2, "b");
assert_eq!(cache.capacity(), 2);

cache.put(3, "c");
assert_eq!(cache.capacity(), 4);

pub fn len(&self) -> usize[src]

Returns the number of key-value pairs that are currently in the the cache. Note that len should be less than or equal to capacity

Example

use aba_cache as cache;
use cache::LruCache;

let mut cache = LruCache::new(2, 60);
assert_eq!(cache.len(), 0);

cache.put(1, "a");
assert_eq!(cache.len(), 1);

cache.put(2, "b");
assert_eq!(cache.len(), 2);
assert_eq!(cache.capacity(), 2);

cache.put(3, "c");
assert_eq!(cache.len(), 3);
assert_eq!(cache.capacity(), 4);

pub fn is_empty(&self) -> bool[src]

Returns a bool indicating whether the cache is empty or not.

Example

use aba_cache as cache;
use cache::LruCache;

let mut cache = LruCache::new(2, 60);
assert!(cache.is_empty());

cache.put(1, "a");
assert!(!cache.is_empty());

Auto Trait Implementations

impl<K, V> RefUnwindSafe for Cache<K, V> where
    K: RefUnwindSafe,
    V: RefUnwindSafe

impl<K, V> Send for Cache<K, V> where
    K: Send + Sync,
    V: Send

impl<K, V> Sync for Cache<K, V> where
    K: Send + Sync,
    V: Sync

impl<K, V> Unpin for Cache<K, V> where
    V: Unpin

impl<K, V> UnwindSafe for Cache<K, V> where
    K: RefUnwindSafe,
    V: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.