next_rust_cache/
memory.rs1use std::collections::HashMap;
2use std::sync::RwLock;
3use std::sync::atomic::{AtomicU64, Ordering};
4
5use crate::{BoxFuture, CacheEntry, CacheError, CacheKey, CacheStore};
6
7pub struct MemoryStore {
13 max_entries: usize,
14 clock: AtomicU64,
15 map: RwLock<HashMap<CacheKey, (CacheEntry, AtomicU64)>>,
16}
17
18impl MemoryStore {
19 pub fn new(max_entries: usize) -> Self {
20 MemoryStore { max_entries: max_entries.max(1), clock: AtomicU64::new(0), map: RwLock::new(HashMap::new()) }
21 }
22
23 pub fn len(&self) -> usize {
24 self.map.read().map(|m| m.len()).unwrap_or(0)
25 }
26
27 pub fn is_empty(&self) -> bool {
28 self.len() == 0
29 }
30
31 fn tick(&self) -> u64 {
32 self.clock.fetch_add(1, Ordering::Relaxed)
33 }
34}
35
36impl CacheStore for MemoryStore {
37 fn get<'a>(&'a self, key: &'a CacheKey) -> BoxFuture<'a, Result<Option<CacheEntry>, CacheError>> {
38 let now = self.tick();
39 let result = self.map.read().ok().and_then(|m| {
40 m.get(key).map(|(e, used)| {
41 used.store(now, Ordering::Relaxed);
42 e.clone()
43 })
44 });
45 Box::pin(async move { Ok(result) })
46 }
47
48 fn set(&self, key: CacheKey, entry: CacheEntry) -> BoxFuture<'_, Result<(), CacheError>> {
49 let now = self.tick();
50 if let Ok(mut m) = self.map.write() {
51 m.insert(key, (entry, AtomicU64::new(now)));
52 while m.len() > self.max_entries {
53 let oldest = m.iter().min_by_key(|(_, (_, used))| used.load(Ordering::Relaxed)).map(|(k, _)| k.clone());
54 match oldest {
55 Some(k) => {
56 m.remove(&k);
57 }
58 None => break,
59 }
60 }
61 }
62 Box::pin(async { Ok(()) })
63 }
64
65 fn delete<'a>(&'a self, key: &'a CacheKey) -> BoxFuture<'a, Result<bool, CacheError>> {
66 let removed = self.map.write().map(|mut m| m.remove(key).is_some()).unwrap_or(false);
67 Box::pin(async move { Ok(removed) })
68 }
69
70 fn delete_tag<'a>(&'a self, tag: &'a str) -> BoxFuture<'a, Result<usize, CacheError>> {
71 let removed = self
72 .map
73 .write()
74 .map(|mut m| {
75 let before = m.len();
76 m.retain(|_, (e, _)| !e.tags.iter().any(|t| t == tag));
77 before - m.len()
78 })
79 .unwrap_or(0);
80 Box::pin(async move { Ok(removed) })
81 }
82
83 fn clear(&self) -> BoxFuture<'_, Result<(), CacheError>> {
84 if let Ok(mut m) = self.map.write() {
85 m.clear();
86 }
87 Box::pin(async { Ok(()) })
88 }
89}