arcache 0.0.2

Thread safe cache implementations with a shared trait to make caches interchangeable.
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

use arcache::{Cache, LFUCache};
use std::thread;

#[derive(Debug, Clone)]
struct Product {
    _id: String,
    _name: String,
    _price: f64,
}

fn fetch_from_api(id: &str) -> Product {
    // Simulate network delay
    thread::sleep(std::time::Duration::from_millis(300));
    Product {
        _id: id.to_string(),
        _name: format!("Product {}", id),
        _price: 100.0,
    }
}

fn get_product(id: &str, cache: &LFUCache<String, Product>) -> Product {
    if let Some(cached) = cache.get(&id.to_string()) {
        return cached.as_ref().clone();
    }
    let product = fetch_from_api(id);
    cache.set(id.to_string(), product.clone());
    product
}

fn main() {
    let cache = LFUCache::<String, Product>::new(10);

    // fetch product 1 five times
    for _ in 0..5 {
        let id = "1";
        let product = get_product(id, &cache);
        println!("Product: {:?}", product);
    }

    // fetch product 2 three times
    for _ in 0..3 {
        let id = "2";
        let product = get_product(id, &cache);
        println!("Product: {:?}", product);
    }

    // fetch product 3 once
    let product = get_product("3", &cache);
    println!("Product: {:?}", product);

    println!("{:?}", cache.stats());
}