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
pub use serde::de::DeserializeOwned; pub use serde::ser::Serialize; pub mod format; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RemoveError { IoError, NoSuchKey, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum LoadRawError { IoError, NoSuchKey, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum LoadError<E> { Raw(LoadRawError), FormatError(E), } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum StoreRawError { IoError, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum StoreError<E> { Raw(StoreRawError), FormatError(E), } pub trait StorageFormat { type SerializeError; type DeserializeError; fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Self::SerializeError> where T: Serialize; fn from_slice<T>(v: &[u8]) -> Result<T, Self::DeserializeError> where T: DeserializeOwned; } pub trait Storage { fn exists<K>(&self, key: K) -> bool where K: AsRef<str>; fn clear(&mut self); fn remove<K>(&mut self, key: K) -> Result<(), RemoveError> where K: AsRef<str>; fn load_raw<K>(&self, key: K) -> Result<Vec<u8>, LoadRawError> where K: AsRef<str>; fn store_raw<K, V>(&mut self, key: K, value: V) -> Result<(), StoreRawError> where K: AsRef<str>, V: AsRef<[u8]>; fn load<K, T, F>(&self, key: K, format: F) -> Result<T, LoadError<F::DeserializeError>> where K: AsRef<str>, T: DeserializeOwned, F: StorageFormat, { let _ = format; self.load_raw(key) .map_err(LoadError::Raw) .and_then(|v| F::from_slice(&v).map_err(LoadError::FormatError)) } fn store<K, T, F>(&mut self, key: K, value: &T, format: F) -> Result<(), StoreError<F::SerializeError>> where K: AsRef<str>, T: Serialize, F: StorageFormat, { let _ = format; F::to_vec(value) .map_err(StoreError::FormatError) .and_then(|v| self.store_raw(key, v).map_err(StoreError::Raw)) } }