Struct izihawa_ttl_cache::TtlCache
source · pub struct TtlCache<K: Eq + Hash, V, S: BuildHasher = RandomState> { /* private fields */ }
Expand description
A time sensitive cache.
Implementations§
source§impl<K: Eq + Hash, V, S: BuildHasher> TtlCache<K, V, S>
impl<K: Eq + Hash, V, S: BuildHasher> TtlCache<K, V, S>
sourcepub fn with_hasher(capacity: usize, hash_builder: S) -> Self
pub fn with_hasher(capacity: usize, hash_builder: S) -> Self
Creates an empty cache that can hold at most capacity
items
with the given hash builder.
sourcepub fn contains_key<Q>(&self, key: &Q) -> boolwhere
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn contains_key<Q>(&self, key: &Q) -> boolwhere K: Borrow<Q>, Q: Hash + Eq + ?Sized,
Check if the cache contains the given key.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(10);
cache.insert(1, "a", Duration::from_secs(30));
assert_eq!(cache.contains_key(&1), true);
sourcepub fn insert(&mut self, k: K, v: V, ttl: Duration) -> Option<V>
pub fn insert(&mut self, k: K, v: V, ttl: Duration) -> Option<V>
Inserts a key-value pair into the cache with an individual ttl for the key. If the key already existed and hasn’t expired, the old value is returned.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
cache.insert(1, "a", Duration::from_secs(20));
cache.insert(2, "b", Duration::from_secs(60));
assert_eq!(cache.get(&1), Some(&"a"));
assert_eq!(cache.get(&2), Some(&"b"));
sourcepub fn get<Q>(&self, k: &Q) -> Option<&V>where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn get<Q>(&self, k: &Q) -> Option<&V>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,
Returns a reference to the value corresponding to the given key in the cache, if it contains an unexpired entry.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
let duration = Duration::from_secs(30);
cache.insert(1, "a", duration);
cache.insert(2, "b", duration);
cache.insert(2, "c", duration);
cache.insert(3, "d", duration);
assert_eq!(cache.get(&1), None);
assert_eq!(cache.get(&2), Some(&"c"));
sourcepub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,
Returns a mutable reference to the value corresponding to the given key in the cache, if it contains an unexpired entry.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
let duration = Duration::from_secs(30);
cache.insert(1, "a", duration);
cache.insert(2, "b", duration);
cache.insert(2, "c", duration);
cache.insert(3, "d", duration);
assert_eq!(cache.get_mut(&1), None);
assert_eq!(cache.get_mut(&2), Some(&mut "c"));
sourcepub fn remove<Q>(&mut self, k: &Q) -> Option<V>where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn remove<Q>(&mut self, k: &Q) -> Option<V>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,
Removes the given key from the cache and returns its corresponding value.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
cache.insert(2, "a", Duration::from_secs(30));
assert_eq!(cache.remove(&1), None);
assert_eq!(cache.remove(&2), Some("a"));
assert_eq!(cache.remove(&2), None);
sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the maximum number of key-value pairs the cache can hold.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache: TtlCache<i32, &str> = TtlCache::new(2);
assert_eq!(cache.capacity(), 2);
sourcepub fn set_capacity(&mut self, capacity: usize)
pub fn set_capacity(&mut self, capacity: usize)
Sets the number of key-value pairs the cache can hold. Removes oldest key-value pairs if necessary.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
let duration = Duration::from_secs(30);
cache.insert(1, "a", duration);
cache.insert(2, "b", duration);
cache.insert(3, "c", duration);
assert_eq!(cache.get(&1), None);
assert_eq!(cache.get(&2), Some(&"b"));
assert_eq!(cache.get(&3), Some(&"c"));
cache.set_capacity(3);
cache.insert(1, "a", duration);
cache.insert(2, "b", duration);
assert_eq!(cache.get(&1), Some(&"a"));
assert_eq!(cache.get(&2), Some(&"b"));
assert_eq!(cache.get(&3), Some(&"c"));
cache.set_capacity(1);
assert_eq!(cache.get(&1), None);
assert_eq!(cache.get(&2), Some(&"b"));
assert_eq!(cache.get(&3), None);
pub fn entry(&mut self, k: K) -> Entry<'_, K, V, S>
sourcepub fn iter(&mut self) -> Iter<'_, K, V> ⓘ
pub fn iter(&mut self) -> Iter<'_, K, V> ⓘ
Returns an iterator over the cache’s key-value pairs in oldest to youngest order.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
let duration = Duration::from_secs(30);
cache.insert(1, 10, duration);
cache.insert(2, 20, duration);
cache.insert(3, 30, duration);
let kvs: Vec<_> = cache.iter().collect();
assert_eq!(kvs, [(&2, &20), (&3, &30)]);
sourcepub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ
Returns an iterator over the cache’s key-value pairs in oldest to youngest order with mutable references to the values.
Examples
use std::time::Duration;
use ttl_cache::TtlCache;
let mut cache = TtlCache::new(2);
let duration = Duration::from_secs(30);
cache.insert(1, 10, duration);
cache.insert(2, 20, duration);
cache.insert(3, 30, duration);
let mut n = 2;
for (k, v) in cache.iter_mut() {
assert_eq!(*k, n);
assert_eq!(*v, n * 10);
*v *= 10;
n += 1;
}
assert_eq!(n, 4);
assert_eq!(cache.get(&2), Some(&200));
assert_eq!(cache.get(&3), Some(&300));
sourcepub fn remove_expired(&mut self)
pub fn remove_expired(&mut self)
This will evict all expired records in the cache. Typically expired values will remain in
cache until they are accessed and then they are cleaned up. Calling remove_expired
will have no impact on what values we can access in the cache, it will only hurry up the
removal of expired values. One reason why you would want to call this is if the values
stored in the cache implement Drop and you want to trigger that behavior (i.e. free up file
handles sooner).