indexmap_store 0.1.0

Mutable, persistent key-value store backed by an IndexMap with an append-only log.
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

--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,6 +18,7 @@
 //!
 //! The store owns the file; concurrent writers are not supported.
 
+use bincode::Options;
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use std::fs::{self, File, OpenOptions};
@@ -27,6 +28,13 @@
 
 const LEN_BYTES: usize = 4;
 
+fn codec() -> impl bincode::Options {
+    use bincode::Options;
+    bincode::DefaultOptions::new()
+        .with_little_endian()
+        .with_varint_encoding()
+}
+
 #[derive(Serialize)]
 enum LogRef<'a, K, V> {
     Insert(&'a K, &'a V),
@@ -129,7 +137,7 @@
                 if payload_end > buf.len() {
                     break;
                 }
-                let rec: LogOwned<K, V> = match bincode::deserialize(&buf[payload_start..payload_end]) {
+                let rec: LogOwned<K, V> = match codec().deserialize(&buf[payload_start..payload_end]) {
                     Ok(r) => r,
                     Err(_) => break,
                 };
@@ -220,7 +228,7 @@
     pub fn insert(&mut self, k: K, v: V) -> io::Result<Option<V>> {
         self.scratch.clear();
         self.scratch.extend_from_slice(&[0u8; LEN_BYTES]);
-        bincode::serialize_into(&mut self.scratch, &LogRef::Insert::<K, V>(&k, &v))
+        codec().serialize_into(&mut self.scratch, &LogRef::Insert::<K, V>(&k, &v))
             .map_err(serialize_err)?;
         self.flush_scratch()?;
         let prev = self.map.insert(k, v);
@@ -240,7 +248,7 @@
         }
         self.scratch.clear();
         self.scratch.extend_from_slice(&[0u8; LEN_BYTES]);
-        bincode::serialize_into(&mut self.scratch, &LogRef::Remove::<K, V>(k))
+        codec().serialize_into(&mut self.scratch, &LogRef::Remove::<K, V>(k))
             .map_err(serialize_err)?;
         self.flush_scratch()?;
         let prev = self.map.shift_remove(k);
@@ -268,7 +276,7 @@
 
         self.scratch.clear();
         self.scratch.extend_from_slice(&[0u8; LEN_BYTES]);
-        bincode::serialize_into(&mut self.scratch, &LogRef::Insert::<K, V>(k, v_ref))
+        codec().serialize_into(&mut self.scratch, &LogRef::Insert::<K, V>(k, v_ref))
             .map_err(serialize_err)?;
 
         self.flush_scratch()?;
@@ -299,7 +307,7 @@
             let mut buf = Vec::with_capacity(256);
             for (k, v) in &self.map {
                 buf.clear();
-                bincode::serialize_into(&mut buf, &LogRef::Insert::<K, V>(k, v))
+                codec().serialize_into(&mut buf, &LogRef::Insert::<K, V>(k, v))
                     .map_err(serialize_err)?;
                 writer.write_all(&(buf.len() as u32).to_le_bytes())?;
                 writer.write_all(&buf)?;