general_storage/
lib.rs

1pub use serde::de::DeserializeOwned;
2pub use serde::ser::Serialize;
3
4pub mod format;
5
6#[derive(Debug)]
7pub struct StringError(pub String);
8impl std::fmt::Display for StringError {
9    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10        self.0.fmt(f)
11    }
12}
13impl std::error::Error for StringError {}
14
15#[derive(Debug)]
16pub enum RemoveError {
17    IoError(Box<dyn std::error::Error>),
18    NoSuchKey,
19}
20
21#[derive(Debug)]
22pub enum LoadRawError {
23    IoError(Box<dyn std::error::Error>),
24    NoSuchKey,
25}
26
27#[derive(Debug)]
28pub enum LoadError<E> {
29    Raw(LoadRawError),
30    FormatError(E),
31}
32
33#[derive(Debug)]
34pub enum StoreRawError {
35    IoError(Box<dyn std::error::Error>),
36}
37
38#[derive(Debug)]
39pub enum StoreError<E> {
40    Raw(StoreRawError),
41    FormatError(E),
42}
43
44pub trait StorageFormat {
45    type SerializeError;
46    type DeserializeError;
47
48    fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Self::SerializeError>
49    where
50        T: Serialize;
51
52    fn from_slice<T>(v: &[u8]) -> Result<T, Self::DeserializeError>
53    where
54        T: DeserializeOwned;
55}
56
57pub trait Storage {
58    fn exists<K>(&self, key: K) -> bool
59    where
60        K: AsRef<str>;
61
62    fn clear(&mut self);
63
64    fn remove<K>(&mut self, key: K) -> Result<(), RemoveError>
65    where
66        K: AsRef<str>;
67
68    fn load_raw<K>(&self, key: K) -> Result<Vec<u8>, LoadRawError>
69    where
70        K: AsRef<str>;
71
72    fn store_raw<K, V>(&mut self, key: K, value: V) -> Result<(), StoreRawError>
73    where
74        K: AsRef<str>,
75        V: AsRef<[u8]>;
76
77    fn load<K, T, F>(&self, key: K, format: F) -> Result<T, LoadError<F::DeserializeError>>
78    where
79        K: AsRef<str>,
80        T: DeserializeOwned,
81        F: StorageFormat,
82    {
83        let _ = format;
84        self.load_raw(key)
85            .map_err(LoadError::Raw)
86            .and_then(|v| F::from_slice(&v).map_err(LoadError::FormatError))
87    }
88
89    fn store<K, T, F>(
90        &mut self,
91        key: K,
92        value: &T,
93        format: F,
94    ) -> Result<(), StoreError<F::SerializeError>>
95    where
96        K: AsRef<str>,
97        T: Serialize,
98        F: StorageFormat,
99    {
100        let _ = format;
101        F::to_vec(value)
102            .map_err(StoreError::FormatError)
103            .and_then(|v| self.store_raw(key, v).map_err(StoreError::Raw))
104    }
105}
general_storage/lib.rs

general_storage/
lib.rs
