lib_contra/
deserialize.rs

1pub mod json;
2
3use std::{
4    collections::HashMap,
5    hash::Hash,
6    io::{self, ErrorKind},
7    marker::PhantomData,
8};
9
10use crate::error::AnyError;
11
12use self::error::visiting_but_expected;
13
14macro_rules! decl_deserialize_primitive {
15    ($deserialize_fn: ident) => {
16        fn $deserialize_fn<V: Visitor>(self, v: V) -> Result<V::Value, AnyError>;
17    };
18}
19
20macro_rules! decl_visit_primitive {
21    ($ttype: ident, $visit_fn: ident) => {
22        fn $visit_fn(self, _v: $ttype) -> Result<Self::Value, AnyError> {
23            Err(visiting_but_expected(stringify!($ttype), &self.expected_a()).into())
24        }
25    };
26}
27
28macro_rules! impl_deserialize_primitive {
29    ($ttype: ident, $visit_fn: ident, $deserialize_fn: ident) => {
30        impl Deserialize for $ttype {
31            fn deserialize<D: Deserializer>(des: D) -> Result<Self, AnyError> {
32                struct PrimitiveVisitor {}
33                impl Visitor for PrimitiveVisitor {
34                    type Value = $ttype;
35
36                    fn expected_a(self) -> String {
37                        stringify!($ttype).to_string()
38                    }
39
40                    fn $visit_fn(self, val: $ttype) -> Result<Self::Value, AnyError> {
41                        Ok(val)
42                    }
43                }
44
45                des.$deserialize_fn(PrimitiveVisitor {})
46            }
47        }
48    };
49}
50
51/// Implementors of this trait can be deserialized from any format
52pub trait Deserialize: Sized {
53    fn deserialize<D: Deserializer>(des: D) -> Result<Self, AnyError>;
54}
55
56/// Parses bytes and delegates them to a visitor
57pub trait Deserializer: Sized {
58    fn deserialize_map<V: Visitor>(self, v: V) -> Result<V::Value, AnyError>;
59    fn deserialize_seq<V: Visitor>(self, v: V) -> Result<V::Value, AnyError>;
60    fn deserialize_struct<V: Visitor>(self, v: V) -> Result<V::Value, AnyError>;
61    fn deserialize_str<V: Visitor>(self, v: V) -> Result<V::Value, AnyError>;
62
63    decl_deserialize_primitive!(deserialize_i8);
64    decl_deserialize_primitive!(deserialize_i16);
65    decl_deserialize_primitive!(deserialize_i32);
66    decl_deserialize_primitive!(deserialize_i64);
67    decl_deserialize_primitive!(deserialize_i128);
68    decl_deserialize_primitive!(deserialize_u8);
69    decl_deserialize_primitive!(deserialize_u16);
70    decl_deserialize_primitive!(deserialize_u32);
71    decl_deserialize_primitive!(deserialize_u64);
72    decl_deserialize_primitive!(deserialize_u128);
73    decl_deserialize_primitive!(deserialize_f32);
74    decl_deserialize_primitive!(deserialize_f64);
75    decl_deserialize_primitive!(deserialize_isize);
76    decl_deserialize_primitive!(deserialize_usize);
77}
78
79/// Maps a parsed value to a Rust type
80pub trait Visitor: Sized {
81    type Value;
82    fn expected_a(self) -> String;
83
84    fn visit_map<M: MapAccess>(self, _map: M) -> Result<Self::Value, AnyError> {
85        Err(visiting_but_expected("map", &self.expected_a()).into())
86    }
87    fn visit_seq<S: SeqAccess>(self, _seq: S) -> Result<Self::Value, AnyError> {
88        Err(visiting_but_expected("seq", &self.expected_a()).into())
89    }
90    fn visit_str(self, _v: &str) -> Result<Self::Value, AnyError> {
91        Err(visiting_but_expected("str", &self.expected_a()).into())
92    }
93
94    decl_visit_primitive!(i8, visit_i8);
95    decl_visit_primitive!(i16, visit_i16);
96    decl_visit_primitive!(i32, visit_i32);
97    decl_visit_primitive!(i64, visit_i64);
98    decl_visit_primitive!(i128, visit_i128);
99    decl_visit_primitive!(u8, visit_u8);
100    decl_visit_primitive!(u16, visit_u16);
101    decl_visit_primitive!(u32, visit_u32);
102    decl_visit_primitive!(u64, visit_u64);
103    decl_visit_primitive!(u128, visit_u128);
104    decl_visit_primitive!(f32, visit_f32);
105    decl_visit_primitive!(f64, visit_f64);
106    decl_visit_primitive!(usize, visit_usize);
107    decl_visit_primitive!(isize, visit_isize);
108}
109
110/// Allows the access to key-value pairs
111pub trait MapAccess {
112    fn next_value<V: Deserialize>(&mut self) -> Result<V, AnyError>;
113    fn next_key<K: Deserialize>(&mut self) -> Result<Option<K>, AnyError>;
114}
115
116/// Allows the access to sequences
117pub trait SeqAccess {
118    fn next_value<V: Deserialize>(&mut self) -> Result<Option<V>, AnyError>;
119}
120
121// ##########################################
122
123mod error {
124    pub(crate) fn visiting_but_expected(etype: &str, gtype: &str) -> String {
125        "visiting a ".to_string() + etype + " but expected a " + gtype
126    }
127}
128
129// ##########################################
130
131/// Utility functions for io::Read and io::Seek
132pub trait Peek {
133    fn peek(&mut self) -> Result<Option<u8>, AnyError>;
134    fn read_until(&mut self, end: &[u8]) -> Result<Vec<u8>, AnyError>;
135    fn consume(&mut self) -> Result<(), AnyError>;
136    fn consume_matching(&mut self, matches: &[u8]) -> Result<(), AnyError>;
137}
138
139impl<R: io::Read + io::Seek> Peek for R {
140    fn peek(&mut self) -> Result<Option<u8>, AnyError> {
141        let start = self.stream_position()?;
142        let mut char: [u8; 1] = [0];
143        let char = match self.read_exact(&mut char) {
144            Ok(_) => Ok(Some(char)),
145            Err(ref e) if e.kind() == ErrorKind::UnexpectedEof => Ok(None),
146            Err(err) => Err(err),
147        };
148        self.seek(io::SeekFrom::Start(start))?;
149        char.map(|o| {
150            if o.is_some() {
151                return Some(*o.unwrap().get(0).unwrap());
152            }
153            return None;
154        })
155        .map_err(|e| e.into())
156    }
157
158    fn consume(&mut self) -> Result<(), AnyError> {
159        self.seek(io::SeekFrom::Current(1))?;
160        Ok(())
161    }
162
163    fn consume_matching(&mut self, matches: &[u8]) -> Result<(), AnyError> {
164        loop {
165            let char = self.peek()?;
166            if char.is_some() && matches.contains(&char.unwrap()) {
167                self.consume()?;
168            } else {
169                break;
170            }
171        }
172        Ok(())
173    }
174
175    fn read_until(&mut self, end: &[u8]) -> Result<Vec<u8>, AnyError> {
176        let mut vec = vec![];
177        loop {
178            let char = self.peek()?;
179            if char.is_some() && !end.contains(&char.unwrap()) {
180                self.consume()?;
181                vec.push(char.unwrap());
182            } else {
183                break;
184            }
185        }
186        Ok(vec)
187    }
188}
189
190// ##########################################
191impl Deserialize for String {
192    fn deserialize<D: Deserializer>(des: D) -> Result<Self, AnyError> {
193        struct StringVisitor {}
194        impl Visitor for StringVisitor {
195            type Value = String;
196
197            fn expected_a(self) -> String {
198                "string".to_string()
199            }
200
201            fn visit_str(self, v: &str) -> Result<Self::Value, AnyError> {
202                Ok(v.to_string())
203            }
204        }
205
206        des.deserialize_str(StringVisitor {})
207    }
208}
209
210impl<I: Deserialize> Deserialize for Vec<I> {
211    fn deserialize<D: Deserializer>(des: D) -> Result<Self, AnyError> {
212        struct VecVisitor<I> {
213            marker: PhantomData<I>,
214        }
215        impl<I: Deserialize> Visitor for VecVisitor<I> {
216            type Value = Vec<I>;
217
218            fn expected_a(self) -> String {
219                "vec".to_string()
220            }
221
222            fn visit_seq<S: SeqAccess>(self, mut seq: S) -> Result<Self::Value, AnyError> {
223                let mut vec = vec![];
224
225                while let Some(item) = seq.next_value()? {
226                    vec.push(item);
227                }
228
229                Ok(vec)
230            }
231        }
232
233        des.deserialize_seq(VecVisitor {
234            marker: PhantomData::<I>,
235        })
236    }
237}
238
239impl<K: Deserialize + Hash + Eq, V: Deserialize> Deserialize for HashMap<K, V> {
240    fn deserialize<D: Deserializer>(des: D) -> Result<Self, AnyError> {
241        struct HashMapVisitor<K, V> {
242            k_marker: PhantomData<K>,
243            v_marker: PhantomData<V>,
244        }
245        impl<K: Deserialize + Hash + Eq, V: Deserialize> Visitor for HashMapVisitor<K, V> {
246            type Value = HashMap<K, V>;
247
248            fn expected_a(self) -> String {
249                "hashmap".to_string()
250            }
251
252            fn visit_map<M: MapAccess>(self, mut map: M) -> Result<Self::Value, AnyError> {
253                let mut tmp = HashMap::new();
254
255                while let Some(key) = map.next_key()? {
256                    let value = map.next_value()?;
257                    tmp.insert(key, value);
258                }
259
260                Ok(tmp)
261            }
262        }
263
264        des.deserialize_map(HashMapVisitor {
265            k_marker: PhantomData,
266            v_marker: PhantomData,
267        })
268    }
269}
270
271impl_deserialize_primitive!(i8, visit_i8, deserialize_i8);
272impl_deserialize_primitive!(i16, visit_i16, deserialize_i16);
273impl_deserialize_primitive!(i32, visit_i32, deserialize_i32);
274impl_deserialize_primitive!(i64, visit_i64, deserialize_i64);
275impl_deserialize_primitive!(i128, visit_i128, deserialize_i128);
276impl_deserialize_primitive!(u8, visit_u8, deserialize_u8);
277impl_deserialize_primitive!(u16, visit_u16, deserialize_u16);
278impl_deserialize_primitive!(u32, visit_u32, deserialize_u32);
279impl_deserialize_primitive!(u64, visit_u64, deserialize_u64);
280impl_deserialize_primitive!(u128, visit_u128, deserialize_u128);
281impl_deserialize_primitive!(f32, visit_f32, deserialize_f32);
282impl_deserialize_primitive!(f64, visit_f64, deserialize_f64);
283impl_deserialize_primitive!(isize, visit_isize, deserialize_isize);
284impl_deserialize_primitive!(usize, visit_usize, deserialize_usize);
lib_contra/deserialize.rs

lib_contra/
deserialize.rs
