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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
use super::Cache as InnerCache;
use std::{borrow::Borrow, hash::Hash, sync::Arc, time::Duration};
use tokio::{sync::Mutex, task, time};
/// Async version of Cache with LRU eviction strategy
pub struct Cache<K, V>(Mutex<InnerCache<K, V>>);
#[allow(clippy::needless_doctest_main)]
impl<K: 'static + Hash + Eq + Sync + Send, V: 'static + Clone + Send> Cache<K, V> {
/// 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 new(multiply_cap: usize, timeout_secs: u64) -> Arc<Self> {
let cache = Arc::new(Cache(Mutex::new(InnerCache::new(
multiply_cap,
timeout_secs,
))));
let cache_async = cache.clone();
task::spawn(async move {
let duration = Duration::from_secs(timeout_secs);
loop {
time::delay_for(duration).await;
cache_async.evict().await
}
});
cache
}
/// Returns the clone 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::LruAsyncCache;
///
/// #[tokio::main]
/// async fn main() {
/// let cache = LruAsyncCache::new(2, 60);
///
/// assert_eq!(cache.put(String::from("1"), "a").await, None);
/// assert_eq!(cache.put(String::from("2"), "b").await, None);
/// assert_eq!(cache.put(String::from("2"), "c").await, Some("b"));
/// assert_eq!(cache.put(String::from("3"), "d").await, None);
///
/// assert_eq!(cache.get(&String::from("1")).await, Some("a"));
/// assert_eq!(cache.get(&String::from("2")).await, Some("c"));
/// assert_eq!(cache.get(&String::from("3")).await, Some("d"));
/// }
/// ```
pub async fn get<Q: ?Sized>(&self, key: &Q) -> Option<V>
where
Arc<K>: Borrow<Q>,
Q: Hash + Eq,
{
let mut cache = self.0.lock().await;
cache.get(key).cloned()
}
/// 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::LruAsyncCache;
///
/// #[tokio::main]
/// async fn main() {
/// let cache = LruAsyncCache::new(2, 60);
///
/// assert_eq!(None, cache.put(String::from("1"), "a").await);
/// assert_eq!(None, cache.put(String::from("2"), "b").await);
/// assert_eq!(Some("b"), cache.put(String::from("2"), "beta").await);
///
/// assert_eq!(cache.get(&String::from("1")).await, Some("a"));
/// assert_eq!(cache.get(&String::from("2")).await, Some("beta"));
/// }
/// ```
pub async fn put(&self, key: K, value: V) -> Option<V> {
let mut cache = self.0.lock().await;
cache.put(key, value)
}
/// Removes expired entry.
/// This operation will deallocate empty slab caused by entry removal if any.
async fn evict(&self) {
let mut cache = self.0.lock().await;
cache.evict();
}
/// 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::LruAsyncCache;
///
/// #[tokio::main]
/// async fn main() {
/// let cache = LruAsyncCache::new(2, 60);
/// assert_eq!(cache.capacity().await, 2);
///
/// cache.put(1, "a").await;
/// assert_eq!(cache.capacity().await, 2);
///
/// cache.put(2, "b").await;
/// assert_eq!(cache.capacity().await, 2);
///
/// cache.put(3, "c").await;
/// assert_eq!(cache.capacity().await, 4);
/// }
/// ```
pub async fn capacity(&self) -> usize {
let cache = self.0.lock().await;
cache.capacity()
}
/// 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::LruAsyncCache;
///
/// #[tokio::main]
/// async fn main() {
/// let cache = LruAsyncCache::new(2, 60);
/// assert_eq!(cache.len().await, 0);
///
/// cache.put(1, "a").await;
/// assert_eq!(cache.len().await, 1);
///
/// cache.put(2, "b").await;
/// assert_eq!(cache.len().await, 2);
/// assert_eq!(cache.capacity().await, 2);
///
/// cache.put(3, "c").await;
/// assert_eq!(cache.len().await, 3);
/// assert_eq!(cache.capacity().await, 4);
/// }
/// ```
pub async fn len(&self) -> usize {
let cache = self.0.lock().await;
cache.len()
}
/// Returns a bool indicating whether the cache is empty or not.
///
/// # Example
///
/// ```
/// use aba_cache as cache;
/// use cache::LruAsyncCache;
///
/// #[tokio::main]
/// async fn main() {
/// let cache = LruAsyncCache::new(2, 60);
/// assert!(cache.is_empty().await);
///
/// cache.put(String::from("1"), "a").await;
/// assert!(!cache.is_empty().await);
/// }
/// ```
pub async fn is_empty(&self) -> bool {
let cache = self.0.lock().await;
cache.is_empty()
}
}