crude_cache 0.1.1

A simple utility for good enough concurrent caching needs.
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

# CrudeCache

![Crates.io](https://img.shields.io/crates/v/crude_cache)
![Docs.rs](https://docs.rs/crude_cache/badge.svg)
![License](https://img.shields.io/crates/l/crude_cache)

`CrudeCache` is a simple utility for good enough concurrent caching needs. Inspired by Play Framework's cache.getOrElseUpdate.

```rust
//Returns non-expired cached item. If one does not exist, new item will be cached & returned
cache.get_or_else_update("cache_key", Duration::from_secs(60), async_function).await
```

**Disclaimer:** Please note that `CrudeCache` was developed for personal projects, it is not battle-tested in production and might contain bugs. Feedback, suggestions, and contributions are more than welcome.

## Features

- Expiration of cached items are evaluated lazily.
- To minimize contention points, items are stored in a `ShardedMap`, which splits the data across multiple shards (`HashMaps`). No bells and whistles, and no resharding.
- Each shard is behind `tokio::sync::RwLock`

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
crude_cache = "0.1.1"
```

## Example usage

```rust
use crude_cache::CrudeCache;

#[derive(Clone)]
pub struct DataService {
    cache: Arc<CrudeCache>,
    db: Arc<Db>
}

impl DataService {
    pub async fn get_big_data(&self) -> SomeBigType {
        self.cache.get_or_else_update("big_data", Duration::from_secs(60), || self.db.big_data()).await
    }

    pub async fn get_other_data(&self) -> OtherType {
        self.cache.get_or_else_update("other_data", Duration::from_secs(60), || self.db.other_data()).await
    }
}
```

## Similar Crates

More sophisticated alternative:

- [cached](https://crates.io/crates/cached)