rustycache 1.0.0

A simple and easy-to-use caching library for Rust.
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# RustyCache Rust Library
![Rust](https://img.shields.io/badge/Rust-lang-000000.svg?style=flat&logo=rust)
[![Rust](https://github.com/Q300Z/easycache/actions/workflows/ci.yml/badge.svg)](https://github.com/Q300Z/easycache/actions/workflows/ci.yml)
[![Crates.io](https://img.shields.io/crates/v/rustycache.svg)](https://crates.io/crates/rustycache)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A generic, thread-safe, asynchronous cache library in Rust implementing multiple cache eviction strategies with TTL and background cleaning.

## Features

- Supports multiple cache eviction strategies:
    - **LFU** (Least Frequently Used)
    - **FIFO** (First In First Out)
- Thread-safe with `Arc<Mutex<...>>`
- Time-to-live (TTL) expiration on entries
- Background cleaner task using Tokio async runtime
- Generic over keys and values (with necessary trait bounds)
- Simple trait-based `CacheStrategy` interface for easy extension

## Usage

### Add dependency

Add this crate to your `Cargo.toml`:

```toml
rustycache = { path = "path/to/rustycache" }
```
Or if published on crates.io, replace with version:
```toml
rustycache = "1.0"
```
### Example: Using LFU Cache
```rust
use easycache::LFUCache;
use std::time::Duration;

#[tokio::main]
async fn main() {
    // Create LFU cache with capacity 100, TTL 60 seconds, cleaner interval 10 seconds
    let mut cache = Easycache::new(100, Duration::from_secs(60), Duration::from_secs(10), easycache::strategy::StrategyType::LFU);

    // Put some values
    cache.put("key1".to_string(), "value1".to_string());
    cache.put("key2".to_string(), "value2".to_string());

    // Get a value
    if let Some(val) = cache.get(&"key1".to_string()) {
        println!("Got: {}", val);
    } else {
        println!("Key expired or not found");
    }
}
```
### Example: Using FIFO Cache
```rust
use easycache::FIFOCache;
use std::time::Duration;

#[tokio::main]
async fn main() {
    // Create FIFO cache with capacity 50, TTL 120 seconds, cleaner interval 15 seconds
    let mut cache = Easycache::new(50, Duration::from_secs(120), Duration::from_secs(15), easycache::strategy::StrategyType::FIFO);

    // Put some values
    cache.put("foo".to_string(), 123);
    cache.put("bar".to_string(), 456);

    // Get a value
    if let Some(val) = cache.get(&"foo".to_string()) {
        println!("Got: {}", val);
    } else {
        println!("Key expired or not found");
    }
}
```
## Testing
To run the tests, use the following command:

```bash
cargo test
```
Tests cover cache insertion, eviction, TTL expiration, concurrency safety, and cleanup logic.
## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.