1use crate::serde::error::DataError;
2use crate::DataReader;
3use anyhow::{anyhow, Result};
4use paste::paste;
5use serde::de::{DeserializeSeed, Visitor};
6use serde::Deserializer;
7
8macro_rules! make_deserialize {
9 ($t:ty) => {
10 paste!{
11 #[inline]
12 fn [<deserialize_ $t>]<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
13 V: Visitor<'de> {
14 visitor.[<visit_ $t>]( self.read_fixed::<$t>()?)
15 }
16 }
17 };
18}
19
20impl<'de, 'a, 'b> Deserializer<'de> for &'a mut DataReader<'b>
21where
22 'b: 'de,
23{
24 type Error = DataError;
25
26 #[inline]
27 fn deserialize_any<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
28 where
29 V: Visitor<'de>,
30 {
31 Err(DataError::AnyNotSupported)
32 }
33
34 make_deserialize!(bool);
35 make_deserialize!(i8);
36 make_deserialize!(u8);
37 make_deserialize!(i16);
38 make_deserialize!(u16);
39 make_deserialize!(i32);
40 make_deserialize!(u32);
41 make_deserialize!(i64);
42 make_deserialize!(u64);
43 make_deserialize!(i128);
44 make_deserialize!(u128);
45 make_deserialize!(f32);
46 make_deserialize!(f64);
47
48 #[inline]
49 fn deserialize_char<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
50 where
51 V: Visitor<'de>,
52 {
53 self.deserialize_str(visitor)
54 }
55
56 #[inline]
57 fn deserialize_str<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
58 where
59 V: Visitor<'de>,
60 {
61 if self.mode == 1 {
62 return Err(DataError::Reset);
63 }
64 let str = self.read_fixed_str()?;
65 visitor.visit_borrowed_str(str)
66 }
67
68 #[inline]
69 fn deserialize_string<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
70 where
71 V: Visitor<'de>,
72 {
73 self.deserialize_str(visitor)
74 }
75
76 #[inline]
77 fn deserialize_bytes<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
78 where
79 V: Visitor<'de>,
80 {
81 if self.mode == 1 {
82 return Err(DataError::Reset);
83 }
84
85 let buff = self.read_fixed_buf()?;
86 visitor.visit_borrowed_bytes(buff)
87 }
88
89 #[inline]
90 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
91 where
92 V: Visitor<'de>,
93 {
94 self.deserialize_bytes(visitor)
95 }
96
97 #[inline]
98 fn deserialize_option<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
99 where
100 V: Visitor<'de>,
101 {
102 if self.mode == 1 {
103 return Err(DataError::Reset);
104 }
105
106 if self.read_fixed::<u8>()? == 0 {
107 visitor.visit_none()
108 } else {
109 visitor.visit_some(self)
110 }
111 }
112
113 #[inline]
114 fn deserialize_unit<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
115 where
116 V: Visitor<'de>,
117 {
118 if self.mode == 1 {
119 return Err(DataError::Reset);
120 }
121
122 if self.read_fixed::<u8>()? == 0 {
123 return Err(anyhow!("deserialize_unit: current data !=0u8").into());
124 }
125
126 visitor.visit_unit()
127 }
128
129 #[inline]
130 fn deserialize_unit_struct<V>(
131 self,
132 _name: &'static str,
133 visitor: V,
134 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
135 where
136 V: Visitor<'de>,
137 {
138 if self.mode == 1 {
139 return Err(DataError::Reset);
140 }
141 self.deserialize_unit(visitor)
142 }
143
144 #[inline]
145 fn deserialize_newtype_struct<V>(
146 self,
147 _name: &'static str,
148 visitor: V,
149 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
150 where
151 V: Visitor<'de>,
152 {
153 if self.mode == 1 {
154 return Err(DataError::Reset);
155 }
156 visitor.visit_newtype_struct(self)
157 }
158
159 #[inline]
160 fn deserialize_seq<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
161 where
162 V: Visitor<'de>,
163 {
164 if self.mode == 1 {
165 return Err(DataError::Reset);
166 }
167 visitor.visit_seq(SeqAssess::new(self)?)
168 }
169
170 #[inline]
171 fn deserialize_tuple<V>(
172 self,
173 _len: usize,
174 visitor: V,
175 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
176 where
177 V: Visitor<'de>,
178 {
179 if self.mode == 1 {
180 return Err(DataError::Reset);
181 }
182 self.deserialize_seq(visitor)
183 }
184
185 #[inline]
186 fn deserialize_tuple_struct<V>(
187 self,
188 _name: &'static str,
189 _len: usize,
190 visitor: V,
191 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
192 where
193 V: Visitor<'de>,
194 {
195 if self.mode == 1 {
196 return Err(DataError::Reset);
197 }
198 self.deserialize_seq(visitor)
199 }
200
201 #[inline]
202 fn deserialize_map<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
203 where
204 V: Visitor<'de>,
205 {
206 if self.mode == 1 {
207 return Err(DataError::Reset);
208 }
209 visitor.visit_map(MapAccess::new(self)?)
210 }
211
212 #[inline]
213 fn deserialize_struct<V>(
214 self,
215 _name: &'static str,
216 _fields: &'static [&'static str],
217 visitor: V,
218 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
219 where
220 V: Visitor<'de>,
221 {
222 if self.mode == 1 {
223 return Err(DataError::Reset);
224 }
225 visitor.visit_map(MapAccess::new(self)?)
226 }
227
228 #[inline]
229 fn deserialize_enum<V>(
230 self,
231 _name: &'static str,
232 _variants: &'static [&'static str],
233 visitor: V,
234 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
235 where
236 V: Visitor<'de>,
237 {
238 if self.mode == 1 {
239 return Err(DataError::Reset);
240 }
241 visitor.visit_enum(VariantAccess::new(self)?)
242 }
243
244 #[inline]
245 fn deserialize_identifier<V>(
246 self,
247 visitor: V,
248 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
249 where
250 V: Visitor<'de>,
251 {
252 if self.mode == 1 {
253 return Err(DataError::Reset);
254 }
255 self.deserialize_str(visitor)
256 }
257
258 #[inline]
259 fn deserialize_ignored_any<V>(
260 self,
261 _visitor: V,
262 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
263 where
264 V: Visitor<'de>,
265 {
266 Err(DataError::IgnoredAnyNotSupported)
267 }
268}
269
270struct SeqAssess<'a, 'b> {
271 len: u32,
272 current: u32,
273 data: &'a mut DataReader<'b>,
274}
275
276impl<'a, 'b> SeqAssess<'a, 'b> {
277 #[inline]
278 pub fn new(data: &'a mut DataReader<'b>) -> Result<Self, DataError> {
279 if data.mode == 1 {
280 return Err(DataError::Reset);
281 }
282
283 let len = data.read_fixed::<u32>()?;
284 Ok(SeqAssess {
285 len,
286 current: 0,
287 data,
288 })
289 }
290}
291
292impl<'a, 'de, 'b: 'de> serde::de::SeqAccess<'de> for SeqAssess<'a, 'b> {
293 type Error = DataError;
294 #[inline]
295 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
296 where
297 T: DeserializeSeed<'de>,
298 {
299 if self.current < self.len {
300 let r = seed.deserialize(&mut *self.data)?;
301 self.current += 1;
302 Ok(Some(r))
303 } else {
304 Ok(None)
305 }
306 }
307}
308
309struct MapAccess<'a, 'b> {
310 data: &'a mut DataReader<'b>,
311 len: u32,
312 current: u32,
313}
314
315impl<'a, 'b> MapAccess<'a, 'b> {
316 #[inline]
317 pub fn new(data: &'a mut DataReader<'b>) -> Result<Self, DataError> {
318 let len = data.read_fixed::<u32>()?;
319 Ok(MapAccess {
320 data,
321 len,
322 current: 0,
323 })
324 }
325}
326
327impl<'de, 'a, 'b: 'de> serde::de::MapAccess<'de> for MapAccess<'a, 'b> {
328 type Error = DataError;
329
330 #[inline]
331 fn next_key_seed<K>(
332 &mut self,
333 seed: K,
334 ) -> Result<Option<<K as DeserializeSeed<'de>>::Value>, Self::Error>
335 where
336 K: DeserializeSeed<'de>,
337 {
338 if self.current < self.len {
339 let r = seed.deserialize(&mut *self.data)?;
340 self.current += 1;
341 Ok(Some(r))
342 } else {
343 Ok(None)
344 }
345 }
346
347 #[inline]
348 fn next_value_seed<V>(
349 &mut self,
350 seed: V,
351 ) -> Result<<V as DeserializeSeed<'de>>::Value, Self::Error>
352 where
353 V: DeserializeSeed<'de>,
354 {
355 seed.deserialize(&mut *self.data)
356 }
357}
358
359struct VariantAccess<'a, 'b> {
360 data: &'a mut DataReader<'b>,
361}
362
363impl<'a, 'b> VariantAccess<'a, 'b> {
364 #[inline]
365 pub fn new(data: &'a mut DataReader<'b>) -> Result<Self, DataError> {
366 Ok(VariantAccess { data })
367 }
368}
369
370impl<'de, 'a, 'b: 'de> serde::de::EnumAccess<'de> for VariantAccess<'a, 'b> {
371 type Error = DataError;
372 type Variant = Self;
373 #[inline]
374 fn variant_seed<V>(
375 self,
376 seed: V,
377 ) -> Result<(<V as DeserializeSeed<'de>>::Value, Self::Variant), Self::Error>
378 where
379 V: DeserializeSeed<'de>,
380 {
381 Ok((seed.deserialize(&mut *self.data)?, self))
382 }
383}
384
385impl<'de, 'a, 'b: 'de> serde::de::VariantAccess<'de> for VariantAccess<'a, 'b> {
386 type Error = DataError;
387
388 #[inline]
389 fn unit_variant(self) -> Result<(), Self::Error> {
390 serde::de::Deserialize::deserialize(self.data)
391 }
392
393 #[inline]
394 fn newtype_variant_seed<T>(
395 self,
396 seed: T,
397 ) -> Result<<T as DeserializeSeed<'de>>::Value, Self::Error>
398 where
399 T: DeserializeSeed<'de>,
400 {
401 seed.deserialize(self.data)
402 }
403
404 #[inline]
405 fn tuple_variant<V>(
406 self,
407 _len: usize,
408 visitor: V,
409 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
410 where
411 V: Visitor<'de>,
412 {
413 serde::de::Deserializer::deserialize_seq(self.data, visitor)
414 }
415
416 #[inline]
417 fn struct_variant<V>(
418 self,
419 fields: &'static [&'static str],
420 visitor: V,
421 ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
422 where
423 V: Visitor<'de>,
424 {
425 serde::de::Deserializer::deserialize_struct(self.data, "", fields, visitor)
426 }
427}