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 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
extern crate bincode; extern crate prototty_storage; extern crate serde; pub use prototty_storage::{LoadError, Storage, StoreError}; use serde::de::DeserializeOwned; use serde::ser::Serialize; use std::collections::HashMap; pub trait StoreBytes { fn store(&mut self, bytes: &[u8]); } pub struct MonoStorage<S: StoreBytes> { table: HashMap<String, Vec<u8>>, store_bytes: S, } impl<S: StoreBytes> MonoStorage<S> { pub fn new(store_bytes: S) -> Self { let table = HashMap::new(); Self { table, store_bytes } } pub fn from_bytes(bytes: &[u8], store_bytes: S) -> Option<Self> { bincode::deserialize(bytes) .ok() .map(|table| Self { table, store_bytes }) } pub fn from_bytes_or_empty(bytes: &[u8], store_bytes: S) -> Self { match bincode::deserialize(bytes).ok() { Some(table) => Self { table, store_bytes }, None => Self::new(store_bytes), } } fn to_bytes(&self) -> Vec<u8> { bincode::serialize(&self.table).expect("Failed to serialize") } fn sync(&mut self) { let bytes = self.to_bytes(); self.store_bytes.store(&bytes); } } impl<S: StoreBytes> Storage for MonoStorage<S> { fn load<K, T>(&self, key: K) -> Result<T, LoadError> where K: AsRef<str>, T: DeserializeOwned, { bincode::deserialize(self.load_raw(key)?.as_slice()).map_err(|_| LoadError::InvalidFormat) } fn remove<K, T>(&mut self, key: K) -> Result<T, LoadError> where K: AsRef<str>, T: DeserializeOwned, { let bytes = self.remove_raw(key)?; bincode::deserialize(&bytes).map_err(|_| LoadError::InvalidFormat) } fn load_raw<K>(&self, key: K) -> Result<Vec<u8>, LoadError> where K: AsRef<str>, { self.table .get(key.as_ref()) .cloned() .ok_or(LoadError::NoSuchKey) } fn store_raw<K, V>(&mut self, key: K, value: V) -> Result<(), StoreError> where K: AsRef<str>, V: AsRef<[u8]>, { { let slice = value.as_ref(); let buf = self .table .entry(key.as_ref().to_string()) .or_insert_with(Vec::new); buf.resize(slice.len(), 0); buf.copy_from_slice(slice); } self.sync(); Ok(()) } fn remove_raw<K>(&mut self, key: K) -> Result<Vec<u8>, LoadError> where K: AsRef<str>, { let ret = self.table.remove(key.as_ref()).ok_or(LoadError::NoSuchKey); self.sync(); ret } fn exists<K>(&self, key: K) -> bool where K: AsRef<str>, { self.table.contains_key(key.as_ref()) } fn clear(&mut self) { self.table.clear(); self.sync(); } fn store<K, T>(&mut self, key: K, value: &T) -> Result<(), StoreError> where K: AsRef<str>, T: Serialize, { let bytes = bincode::serialize(value).expect("Failed to serialize data"); self.store_raw(key, bytes)?; Ok(()) } }