graphannis_core/
serializer.rs

1use std::{convert::TryInto, error::Error};
2
3use serde_bytes::ByteBuf;
4
5pub type KeyVec = smallvec::SmallVec<[u8; 32]>;
6
7pub trait KeySerializer {
8    fn create_key(&self) -> KeyVec;
9    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>>
10    where
11        Self: std::marker::Sized;
12}
13
14pub trait FixedSizeKeySerializer: KeySerializer {
15    fn key_size() -> usize;
16}
17
18impl KeySerializer for Vec<u8> {
19    fn create_key(&self) -> KeyVec {
20        KeyVec::from_slice(self)
21    }
22
23    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
24        Ok(Vec::from(key))
25    }
26}
27
28impl KeySerializer for ByteBuf {
29    fn create_key(&self) -> KeyVec {
30        KeyVec::from_slice(self)
31    }
32
33    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
34        Ok(ByteBuf::from(key))
35    }
36}
37
38impl KeySerializer for KeyVec {
39    fn create_key(&self) -> KeyVec {
40        self.clone()
41    }
42
43    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
44        Ok(KeyVec::from(key))
45    }
46}
47
48impl KeySerializer for String {
49    fn create_key(&self) -> KeyVec {
50        KeyVec::from_slice(self.as_bytes())
51    }
52
53    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
54        let v = String::from_utf8_lossy(key);
55        Ok(v.to_string())
56    }
57}
58
59impl KeySerializer for u8 {
60    fn create_key(&self) -> KeyVec {
61        KeyVec::from_slice(&self.to_be_bytes())
62    }
63
64    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
65        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
66        let result = Self::from_be_bytes(as_array);
67        Ok(result)
68    }
69}
70
71impl FixedSizeKeySerializer for u8 {
72    fn key_size() -> usize {
73        std::mem::size_of::<Self>()
74    }
75}
76
77impl KeySerializer for u16 {
78    fn create_key(&self) -> KeyVec {
79        KeyVec::from_slice(&self.to_be_bytes())
80    }
81
82    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
83        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
84        let result = Self::from_be_bytes(as_array);
85        Ok(result)
86    }
87}
88
89impl FixedSizeKeySerializer for u16 {
90    fn key_size() -> usize {
91        std::mem::size_of::<Self>()
92    }
93}
94
95impl KeySerializer for u32 {
96    fn create_key(&self) -> KeyVec {
97        KeyVec::from_slice(&self.to_be_bytes())
98    }
99
100    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
101        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
102        let result = Self::from_be_bytes(as_array);
103        Ok(result)
104    }
105}
106
107impl FixedSizeKeySerializer for u32 {
108    fn key_size() -> usize {
109        std::mem::size_of::<Self>()
110    }
111}
112
113impl KeySerializer for u64 {
114    fn create_key(&self) -> KeyVec {
115        KeyVec::from_slice(&self.to_be_bytes())
116    }
117
118    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
119        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
120        let result = Self::from_be_bytes(as_array);
121        Ok(result)
122    }
123}
124
125impl FixedSizeKeySerializer for u64 {
126    fn key_size() -> usize {
127        std::mem::size_of::<Self>()
128    }
129}
130
131impl KeySerializer for u128 {
132    fn create_key(&self) -> KeyVec {
133        KeyVec::from_slice(&self.to_be_bytes())
134    }
135
136    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
137        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
138        let result = Self::from_be_bytes(as_array);
139        Ok(result)
140    }
141}
142
143impl FixedSizeKeySerializer for u128 {
144    fn key_size() -> usize {
145        std::mem::size_of::<Self>()
146    }
147}
148
149impl KeySerializer for usize {
150    fn create_key(&self) -> KeyVec {
151        KeyVec::from_slice(&self.to_be_bytes())
152    }
153
154    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
155        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
156        let result = Self::from_be_bytes(as_array);
157        Ok(result)
158    }
159}
160
161impl KeySerializer for i8 {
162    fn create_key(&self) -> KeyVec {
163        KeyVec::from_slice(&self.to_be_bytes())
164    }
165
166    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
167        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
168        let result = Self::from_be_bytes(as_array);
169        Ok(result)
170    }
171}
172
173impl FixedSizeKeySerializer for i8 {
174    fn key_size() -> usize {
175        std::mem::size_of::<Self>()
176    }
177}
178
179impl KeySerializer for i16 {
180    fn create_key(&self) -> KeyVec {
181        KeyVec::from_slice(&self.to_be_bytes())
182    }
183
184    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
185        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
186        let result = Self::from_be_bytes(as_array);
187        Ok(result)
188    }
189}
190
191impl FixedSizeKeySerializer for i16 {
192    fn key_size() -> usize {
193        std::mem::size_of::<Self>()
194    }
195}
196
197impl KeySerializer for i32 {
198    fn create_key(&self) -> KeyVec {
199        KeyVec::from_slice(&self.to_be_bytes())
200    }
201
202    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
203        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
204        let result = Self::from_be_bytes(as_array);
205        Ok(result)
206    }
207}
208
209impl FixedSizeKeySerializer for i32 {
210    fn key_size() -> usize {
211        std::mem::size_of::<Self>()
212    }
213}
214
215impl KeySerializer for i64 {
216    fn create_key(&self) -> KeyVec {
217        KeyVec::from_slice(&self.to_be_bytes())
218    }
219
220    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
221        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
222        let result = Self::from_be_bytes(as_array);
223        Ok(result)
224    }
225}
226
227impl FixedSizeKeySerializer for i64 {
228    fn key_size() -> usize {
229        std::mem::size_of::<Self>()
230    }
231}
232
233impl KeySerializer for i128 {
234    fn create_key(&self) -> KeyVec {
235        KeyVec::from_slice(&self.to_be_bytes())
236    }
237
238    fn parse_key(key: &[u8]) -> Result<Self, Box<dyn Error + Send + Sync>> {
239        let as_array = key[..std::mem::size_of::<Self>()].try_into()?;
240        let result = Self::from_be_bytes(as_array);
241        Ok(result)
242    }
243}
244
245impl FixedSizeKeySerializer for i128 {
246    fn key_size() -> usize {
247        std::mem::size_of::<Self>()
248    }
249}
graphannis_core/serializer.rs

graphannis_core/
serializer.rs
