serde_bench/
de.rs

1use crate::{Error, Result};
2use byteorder::{NativeEndian, ReadBytesExt};
3use serde::de::{
4    self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer, SeqAccess, VariantAccess,
5    Visitor,
6};
7use std::str;
8
9pub struct Deserializer<'de> {
10    bytes: &'de [u8],
11}
12
13impl<'de> Deserializer<'de> {
14    pub fn new(bytes: &'de [u8]) -> Self {
15        Deserializer { bytes }
16    }
17
18    #[inline]
19    fn read_slice(&mut self) -> Result<&'de [u8]> {
20        let len = Deserialize::deserialize(&mut *self)?;
21        let (slice, rest) = self.bytes.split_at(len);
22        self.bytes = rest;
23        Ok(slice)
24    }
25
26    #[inline]
27    fn read_str(&mut self) -> Result<&'de str> {
28        str::from_utf8(self.read_slice()?).map_err(Into::into)
29    }
30}
31
32macro_rules! impl_nums {
33    ($dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
34        #[inline]
35        fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
36        where
37            V: Visitor<'de>,
38        {
39            let value = self.bytes.$reader_method::<NativeEndian>()?;
40            visitor.$visitor_method(value)
41        }
42    };
43}
44
45impl<'de> serde::Deserializer<'de> for &mut Deserializer<'de> {
46    type Error = Error;
47
48    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
49    where
50        V: Visitor<'de>,
51    {
52        Err(Error::new("`deserialize_any` is not supported"))
53    }
54
55    #[inline]
56    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
57    where
58        V: Visitor<'de>,
59    {
60        match self.bytes.read_u8()? {
61            1 => visitor.visit_bool(true),
62            0 => visitor.visit_bool(false),
63            _ => Err(Error::new("invalid boolean")),
64        }
65    }
66
67    impl_nums!(deserialize_u16, visit_u16, read_u16);
68    impl_nums!(deserialize_u32, visit_u32, read_u32);
69    impl_nums!(deserialize_u64, visit_u64, read_u64);
70    impl_nums!(deserialize_u128, visit_u128, read_u128);
71    impl_nums!(deserialize_i16, visit_i16, read_i16);
72    impl_nums!(deserialize_i32, visit_i32, read_i32);
73    impl_nums!(deserialize_i64, visit_i64, read_i64);
74    impl_nums!(deserialize_i128, visit_i128, read_i128);
75    impl_nums!(deserialize_f32, visit_f32, read_f32);
76    impl_nums!(deserialize_f64, visit_f64, read_f64);
77
78    #[inline]
79    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
80    where
81        V: Visitor<'de>,
82    {
83        visitor.visit_u8(self.bytes.read_u8()?)
84    }
85
86    #[inline]
87    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
88    where
89        V: Visitor<'de>,
90    {
91        visitor.visit_i8(self.bytes.read_i8()?)
92    }
93
94    #[inline]
95    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
96    where
97        V: Visitor<'de>,
98    {
99        visitor.visit_unit()
100    }
101
102    #[inline]
103    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
104    where
105        V: Visitor<'de>,
106    {
107        let width = utf8_char_width(self.bytes[0]);
108        if width == 1 {
109            return visitor.visit_char(self.bytes[0] as char);
110        }
111        if width == 0 {
112            return Err(Error::new("invalid char"));
113        }
114        let res = match str::from_utf8(&self.bytes[..width]) {
115            Ok(s) => s.chars().next().unwrap(),
116            Err(err) => {
117                return Err(err.into());
118            }
119        };
120        self.bytes = &self.bytes[width..];
121        visitor.visit_char(res)
122    }
123
124    #[inline]
125    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
126    where
127        V: Visitor<'de>,
128    {
129        visitor.visit_borrowed_str(self.read_str()?)
130    }
131
132    #[inline]
133    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
134    where
135        V: Visitor<'de>,
136    {
137        visitor.visit_borrowed_str(self.read_str()?)
138    }
139
140    #[inline]
141    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
142    where
143        V: Visitor<'de>,
144    {
145        visitor.visit_borrowed_bytes(self.read_slice()?)
146    }
147
148    #[inline]
149    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
150    where
151        V: Visitor<'de>,
152    {
153        visitor.visit_borrowed_bytes(self.read_slice()?)
154    }
155
156    #[inline]
157    fn deserialize_enum<V>(
158        self,
159        _enum: &'static str,
160        _variants: &'static [&'static str],
161        visitor: V,
162    ) -> Result<V::Value>
163    where
164        V: Visitor<'de>,
165    {
166        visitor.visit_enum(self)
167    }
168
169    #[inline]
170    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
171    where
172        V: Visitor<'de>,
173    {
174        visitor.visit_seq(self)
175    }
176
177    #[inline]
178    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
179    where
180        V: Visitor<'de>,
181    {
182        match self.bytes.read_u8()? {
183            0 => visitor.visit_none(),
184            1 => visitor.visit_some(self),
185            _ => Err(Error::new("invalid Option")),
186        }
187    }
188
189    #[inline]
190    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
191    where
192        V: Visitor<'de>,
193    {
194        struct SeqAccess<'a, 'de: 'a> {
195            deserializer: &'a mut Deserializer<'de>,
196            remaining: usize,
197        }
198
199        impl<'de, 'a> de::SeqAccess<'de> for SeqAccess<'a, 'de> {
200            type Error = Error;
201
202            #[inline]
203            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
204            where
205                T: DeserializeSeed<'de>,
206            {
207                if self.remaining > 0 {
208                    self.remaining -= 1;
209                    seed.deserialize(&mut *self.deserializer).map(Some)
210                } else {
211                    Ok(None)
212                }
213            }
214        }
215
216        let len = Deserialize::deserialize(&mut *self)?;
217
218        visitor.visit_seq(SeqAccess {
219            deserializer: self,
220            remaining: len,
221        })
222    }
223
224    #[inline]
225    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
226    where
227        V: Visitor<'de>,
228    {
229        struct MapAccess<'a, 'de: 'a> {
230            deserializer: &'a mut Deserializer<'de>,
231            remaining: usize,
232        }
233
234        impl<'de, 'a> de::MapAccess<'de> for MapAccess<'a, 'de> {
235            type Error = Error;
236
237            #[inline]
238            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
239            where
240                K: DeserializeSeed<'de>,
241            {
242                if self.remaining > 0 {
243                    self.remaining -= 1;
244                    seed.deserialize(&mut *self.deserializer).map(Some)
245                } else {
246                    Ok(None)
247                }
248            }
249
250            #[inline]
251            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
252            where
253                V: DeserializeSeed<'de>,
254            {
255                seed.deserialize(&mut *self.deserializer)
256            }
257        }
258
259        let len = Deserialize::deserialize(&mut *self)?;
260
261        visitor.visit_map(MapAccess {
262            deserializer: self,
263            remaining: len,
264        })
265    }
266
267    #[inline]
268    fn deserialize_struct<V>(
269        self,
270        _name: &str,
271        _fields: &'static [&'static str],
272        visitor: V,
273    ) -> Result<V::Value>
274    where
275        V: Visitor<'de>,
276    {
277        visitor.visit_seq(self)
278    }
279
280    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
281    where
282        V: Visitor<'de>,
283    {
284        Err(Error::new("`deserialize_identifier` is not supported"))
285    }
286
287    #[inline]
288    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
289    where
290        V: Visitor<'de>,
291    {
292        visitor.visit_newtype_struct(self)
293    }
294
295    #[inline]
296    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
297    where
298        V: Visitor<'de>,
299    {
300        visitor.visit_unit()
301    }
302
303    #[inline]
304    fn deserialize_tuple_struct<V>(
305        self,
306        _name: &'static str,
307        _len: usize,
308        visitor: V,
309    ) -> Result<V::Value>
310    where
311        V: Visitor<'de>,
312    {
313        visitor.visit_seq(self)
314    }
315
316    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
317    where
318        V: Visitor<'de>,
319    {
320        Err(Error::new("`deserialize_ignored_any` is not supported"))
321    }
322
323    fn is_human_readable(&self) -> bool {
324        false
325    }
326}
327
328// For tuples, structs, tuple structs, and fixed size seqs.
329impl<'de> SeqAccess<'de> for Deserializer<'de> {
330    type Error = Error;
331
332    #[inline]
333    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
334    where
335        T: DeserializeSeed<'de>,
336    {
337        seed.deserialize(self).map(Some)
338    }
339}
340
341impl<'de> EnumAccess<'de> for &mut Deserializer<'de> {
342    type Error = Error;
343    type Variant = Self;
344
345    #[inline]
346    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
347    where
348        V: DeserializeSeed<'de>,
349    {
350        let index = Deserialize::deserialize(&mut *self)?;
351        let deserializer = <u32 as IntoDeserializer<Error>>::into_deserializer(index);
352        let value = seed.deserialize(deserializer)?;
353        Ok((value, self))
354    }
355}
356
357impl<'de> VariantAccess<'de> for &mut Deserializer<'de> {
358    type Error = Error;
359
360    #[inline]
361    fn unit_variant(self) -> Result<()> {
362        Ok(())
363    }
364
365    #[inline]
366    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
367    where
368        T: DeserializeSeed<'de>,
369    {
370        seed.deserialize(self)
371    }
372
373    #[inline]
374    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
375    where
376        V: Visitor<'de>,
377    {
378        visitor.visit_seq(self)
379    }
380
381    #[inline]
382    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
383    where
384        V: Visitor<'de>,
385    {
386        visitor.visit_seq(self)
387    }
388}
389
390#[rustfmt::skip]
391static UTF8_CHAR_WIDTH: [u8; 256] = [
392    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
393    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x1F
394    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x3F
396    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
397    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x5F
398    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x7F
400    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
401    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x9F
402    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
403    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xBF
404    0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
405    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xDF
406    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
407    4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
408];
409
410#[inline]
411fn utf8_char_width(b: u8) -> usize {
412    UTF8_CHAR_WIDTH[b as usize] as usize
413}
serde_bench/de.rs

serde_bench/
de.rs
