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
//! In-Process In-Memory Cache implementation.
//!
//! Supported eviction strategy:
//! - LRU (Least Recently Used, inspired by [LRU Cache](https://github.com/jeromefroe/lru-rs))
//! - LFU (Least Frequently Used, TBD)
//! - MRU (Most Recently Used, TBD)
//! - FIFO (First In First Out, TBD)
//!
//! Supporting async/.await powered by tokio runtime.
//!
//! ## Caveat
//!
//! If you need to use non-asynchronous, just disable default feature for this crate on your `Cargo.toml`
//!
//! If you do need to use reference for your value, on non-asynchronous do use `std::rc::Rc`,
//! and on asynchronous do use `std::sync::Arc`
//!
//! ## Example basic
//!
//! ### Cargo.toml
//!
//! ```toml
//! [dependencies]
//! aba-cache = { version = "0.1", default-features = false }
//! serde_json = { version = "1.0" }
//! ```
//!
//! ### main.rs
//!
//! ```rust,no_run
//! use aba_cache as cache;
//! use cache::LruCache;
//! use serde_json::{self, Value};
//! use std::rc::Rc;
//!
//! // create cache with multiply_cap 1024, and evicting
//! // LRU entry with age 15 minutes or older
//! let mut cache = LruCache::new(1024, 15 * 60);
//!
//! let val_one: Rc<Value> = Rc::new(serde_json::from_str(r#"{"id":1}"#).unwrap());
//! let val_two: Rc<Value> = Rc::new(serde_json::from_str(r#"{"id":2}"#).unwrap());
//!
//! cache.put("one", val_one.clone());
//! cache.put("two", val_two.clone());
//!
//! assert!(
//! if let Some(value) = cache.get(&"one") {
//! *value == val_one
//! } else {
//! false
//! }
//! );
//! assert_eq!(cache.get(&"three"), None);
//! ```
//!
//! ## Example async
//!
//! ### Cargo.toml
//!
//! ```toml
//! aba-cache = { version = "0.1", default-features = false }
//! serde_json = { version = "1.0" }
//! tokio = { version = "0.2", features = ["macros", "rt-core"] }
//! ```
//!
//! ### main.rs
//!
//! ```rust,no_run
//! use aba_cache as cache;
//! use cache::LruAsyncCache;
//! use serde_json::{self, Value};
//! use std::sync::Arc;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//! // create cache with multiply_cap 1024, and evicting
//! // LRU entry with age 15 minutes or older
//! let cache = LruAsyncCache::new(1024, 15 * 60);
//!
//! let val_one: Arc<Value> = Arc::new(serde_json::from_str(r#"{"id":1}"#)?);
//! let val_two: Arc<Value> = Arc::new(serde_json::from_str(r#"{"id":2}"#)?);
//!
//! cache.put("one", val_one.clone()).await;
//! cache.put("two", val_two.clone()).await;
//!
//! assert!(
//! if let Some(value) = cache.get(&"one").await {
//! value == val_one
//! } else {
//! false
//! }
//! );
//! assert_eq!(cache.get(&"three").await, None);
//!
//! Ok(())
//! }
//! ```
pub use Cache as LruAsyncCache;
pub use Cache as LruCache;