tiered-cache 0.1.6

A high-performance multi-tiered cache with automatic sizing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


// src/tier.rs
use super::*;
use lru_mem::HeapSize;

#[allow(dead_code)]
pub(crate) struct Tier<K, V> {
    cache: RwLock<lru_mem::LruCache<K, CacheEntry<V>>>,
    size_range: (usize, usize),
}

impl<K, V> Tier<K, V>
where
    K: Hash + Eq + Clone + HeapSize + Send + Sync + 'static,
    V: Clone + HeapSize + Send + Sync + 'static,
{
    pub fn new(capacity: usize, size_range: (usize, usize)) -> Self {
        Self {
            cache: RwLock::new(lru_mem::LruCache::new(capacity)),
            size_range,
        }
    }

    #[inline]
    pub fn put(&self, key: K, entry: CacheEntry<V>) -> Option<V> {
        let mut cache = self.cache.write();
        match cache.insert(key, entry) {
            Ok(old) => old.map(|e| Arc::try_unwrap(e.value).unwrap_or_else(|arc| (*arc).clone())),
            Err(_) => None
        }
    }

    #[inline]
    pub fn get(&self, key: &K) -> Option<Arc<V>> {
        let mut cache = self.cache.write();
        cache.get(key).map(|entry| entry.value.clone())
    }

    #[inline]
    pub fn remove(&self, key: &K) -> Option<V> {
        let mut cache = self.cache.write();
        cache.remove(key)
            .map(|entry| Arc::try_unwrap(entry.value).unwrap_or_else(|arc| (*arc).clone()))
    }

    pub fn clear(&self) {
        let mut cache = self.cache.write();
        cache.clear();
    }

    pub fn stats(&self, config: &TierConfig) -> TierStats {
        let cache = self.cache.read();
        TierStats {
            items: cache.len(),
            size: cache.iter().map(|(_, entry)| entry.heap_size()).sum(),
            capacity: config.total_capacity,
            hit_count: 0,
            miss_count: 0,
        }
    }
}