Struct disklru::Store

pub struct Store<K, V>where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,{ /* private fields */ }

LRU store, backed by by sled.

The typical use case is: you want a persistent cache, with an interface that has similarities with a basic HashMap. And, you do not want it to grow too much, and prefer to drop on the floor data which has not been accessed for a long time.

LRU is normally used for in-memory caches, but here it’s implemented on something which is persistent. Implementation is inspired from work on the in-memory cache HashLRU.

In most cases this implementation tries to be as close as possible to the standard collections HashMap however there are a few differences:

• keys and values must be (de)serialiable
• keys must implement Eq
• no iterator on mutables
• as it relies on external data, any operation can fail
• inserts take references, gets return owned values

This latest aspect is really the fundamental difference: as here all the data is serialized and stored within the store, returning a reference does not really make any sense. Conversely, when putting values in the store, you don’t need to transfer ownership: the store is going to make a serializable copy anyway.

Examples

use disklru::Store;

let mut store = Store::open_temporary(4).unwrap();
store.insert(&1, &10).unwrap();
store.insert(&2, &20).unwrap();
store.insert(&3, &30).unwrap();
store.insert(&4, &40).unwrap();
store.insert(&5, &50).unwrap();
// key1 has been dropped, size is limited to 4
assert_eq!(Some(2), store.lru().unwrap());
assert_eq!(Some(20), store.get(&2).unwrap());
// getting key2 has made key3 the least recently used item
assert_eq!(Some(3), store.lru().unwrap());
assert_eq!(Some(40), store.get(&4).unwrap());
// getting key4 makes it the most recently used item
assert_eq!("[3: 30, 5: 50, 2: 20, 4: 40]", format!("{}", store));
store.flush().unwrap(); // commit

Implementations

impl<K, V> Store<K, V>where
K: Serialize + DeserializeOwned + Eq,
V: Serialize + DeserializeOwned,

pub fn open_with_config(config: Config, capacity: usize) -> Result<Self>

pub fn open_with_path<P: AsRef<Path>>(path: P, capacity: usize) -> Result<Self>

pub fn open_temporary(capacity: usize) -> Result<Self>

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

pub fn resize(&mut self, capacity: usize) -> Result<usize>

pub fn clear(&mut self) -> Result<()>

pub fn flush(&self) -> Result<usize>

pub async fn flush_async(&self) -> Result<usize>

pub fn mru(&self) -> Result<Option<K>>

pub fn lru(&self) -> Result<Option<K>>

pub fn insert(&mut self, k: &K, v: &V) -> Result<Option<V>>

pub fn push(&mut self, k: &K, v: &V) -> Result<Option<(K, V)>>

pub fn remove(&mut self, k: &K) -> Result<Option<V>>

pub fn pop(&mut self, k: &K) -> Result<Option<(K, V)>>

pub fn pop_lru(&mut self) -> Result<Option<(K, V)>>

pub fn pop_mru(&mut self) -> Result<Option<(K, V)>>

pub fn forget(&mut self, k: &K) -> Result<()>

pub fn forget_mru(&mut self) -> Result<()>

pub fn forget_lru(&mut self) -> Result<()>

pub fn contains_key(&mut self, k: &K) -> Result<bool>

pub fn bump(&mut self, k: &K) -> Result<()>

pub fn get(&mut self, k: &K) -> Result<Option<V>>

pub fn get_key_value(&mut self, k: &K) -> Result<Option<(K, V)>>

pub fn get_lru(&mut self) -> Result<Option<V>>

pub fn peek(&self, k: &K) -> Result<Option<V>>

pub fn peek_mru(&self) -> Result<Option<V>>

pub fn peek_lru(&self) -> Result<Option<V>>

pub fn peek_key_value(&self, k: &K) -> Result<Option<(K, V)>>

pub fn export(&self) -> Export<'_, K, V>

pub fn iter(&self) -> Iter<'_, K, V>

pub fn to_vec(&self) -> Result<Vec<(K, V)>>

pub fn import<I>(&mut self, iter: I) -> Result<usize>where
I: Iterator<Item = (K, V)>,

pub fn import_map_iter<'a, I>(&mut self, iter: I) -> Result<usize>where
K: Serialize + DeserializeOwned + Eq + 'a,
V: Serialize + DeserializeOwned + 'a,
I: Iterator<Item = (&'a K, &'a V)>,

pub fn import_vec_iter<'a, I>(&mut self, iter: I) -> Result<usize>where
K: Serialize + DeserializeOwned + Eq + 'a,
V: Serialize + DeserializeOwned + 'a,
I: Iterator<Item = &'a (K, V)>,

pub fn keys(&self) -> Keys<'_, K, V>

pub fn values(&self) -> Values<'_, K, V>

pub fn export_keys(&self) -> ExportKeys<'_, K, V>

pub fn export_values(&self) -> ExportValues<'_, K, V>

pub fn dump(&self) -> Result<Dump<K, V>>

pub fn restore(&mut self, dump: &Dump<K, V>) -> Result<usize>

impl<K, V> Store<K, V>where
K: Serialize + DeserializeOwned + Eq + Hash,
V: Serialize + DeserializeOwned,

pub fn to_map(&self) -> Result<HashMap<K, V>>

impl<K, V> Store<K, V>where
K: Serialize + DeserializeOwned + Eq + Clone + Debug,
V: Serialize + DeserializeOwned,

pub fn audit(&self) -> Result<()>

Trait Implementations

impl<K, V> Debug for Store<K, V>where
K: Serialize + DeserializeOwned + Eq + Debug,
V: Serialize + DeserializeOwned + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> Display for Store<K, V>where
K: Serialize + DeserializeOwned + Eq + Display,
V: Serialize + DeserializeOwned + Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> PartialEq<Store<K, V>> for Store<K, V>where
K: Serialize + DeserializeOwned + Eq,
V: Serialize + DeserializeOwned + Eq,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V> Eq for Store<K, V>where
K: Serialize + DeserializeOwned + Eq,
V: Serialize + DeserializeOwned + Eq,