stupid-simple-kv 0.1.0

A dead-simple, pluggable, binary-sorted key-value store for Rust with FoundationDB-style keys. In-memory and SQLite backends. Zero-boilerplate and easy iteration.
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

/// In-memory key-value backend using `HashMap`.
use crate::keys::Key;
use crate::storages::kv_backend::{KvBackend, KvResult};
use std::collections::{HashMap, HashSet};

#[derive(Default)]
pub struct MemoryBackend {
    map: HashMap<Key, Vec<u8>>,
}
impl MemoryBackend {
    pub fn new() -> Self {
        Self::default()
    }
}
impl KvBackend for MemoryBackend {
    fn set(&mut self, key: Key, value: Vec<u8>) -> KvResult<()> {
        self.map.insert(key, value);
        Ok(())
    }
    fn get(&self, key: &Key) -> KvResult<Option<Vec<u8>>> {
        Ok(self.map.get(key).cloned())
    }
    fn delete(&mut self, key: &Key) -> KvResult<()> {
        self.map.remove(key);
        Ok(())
    }
    fn clear(&mut self) -> KvResult<()> {
        self.map.clear();
        Ok(())
    }
    fn get_many(
        &self,
        keys: Vec<Key>,
    ) -> KvResult<Box<dyn Iterator<Item = Vec<u8>> + Send + Sync + 'static>> {
        let keyset: HashSet<Key> = keys.into_iter().collect();
        let results = self
            .map
            .iter()
            .filter(move |(k, _)| keyset.contains(k))
            .map(|(_, v)| v.clone())
            .collect::<Vec<_>>()
            .into_iter();
        Ok(Box::new(results))
    }
    fn keys(&self) -> KvResult<Box<dyn Iterator<Item = Key> + Send + Sync + 'static>> {
        let keys = self.map.keys().cloned().collect::<Vec<_>>().into_iter();
        Ok(Box::new(keys))
    }
}