orengine_utils/rw_serde/
deserializer.rs

1//! Deserializer backed by an [`std::io::Read`](Read) implementation.
2//!
3//! This module provides a Serde deserializer that reads values directly from any
4//! type implementing [`std::io::Read`](Read). It uses the same format as
5//! [`bincode`](https://github.com/bincode-org/bincode) with little endian bytes and varints.
6//!
7//! The deserializer performs streaming reads and does not require the entire
8//! input to be buffered in memory.
9//!
10//! # Example
11//!
12//! ```no_run
13//! use std::fs::File;
14//! use serde::Deserialize;
15//! use orengine_utils::rw_serde::RWDeserializer;
16//!
17//! #[derive(Deserialize)]
18//! struct Person {
19//!     id: u64,
20//!     name: String,
21//! }
22//!
23//! let file = File::open("person.bin")?;
24//! let mut deserializer = RWDeserializer::new(file);
25//!
26//! let person: Person = Person::deserialize(&mut deserializer)?;
27//! # Ok::<(), Box<dyn std::error::Error>>(())
28//! ```
29use crate::small_string::SmallString;
30use crate::varint::ReadVarInt;
31use serde::de::{
32    self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess,
33    Visitor,
34};
35use smallvec::SmallVec;
36use std::fmt::{Display, Formatter};
37use std::io::Read;
38
39/// A streaming Serde deserializer over any [`std::io::Read`](Read) source.
40///
41/// Values are read sequentially from the underlying reader using the crate's
42/// binary encoding.
43pub struct RWDeserializer<Src: Read> {
44    source: Src,
45}
46
47impl<Src: Read> RWDeserializer<Src> {
48    /// Creates a new deserializer from a reader.
49    pub fn new(source: Src) -> Self {
50        Self { source }
51    }
52
53    /// Consumes the deserializer and returns the wrapped reader.
54    pub fn into_inner(self) -> Src {
55        self.source
56    }
57
58    /// Returns a mutable reference to the underlying reader.
59    pub fn as_sr_mut(&mut self) -> &mut Src {
60        &mut self.source
61    }
62
63    /// Returns a shared reference to the underlying reader.
64    pub fn as_src(&self) -> &Src {
65        &self.source
66    }
67}
68
69/// Errors that can occur while deserializing data.
70///
71/// These errors represent either I/O failures or malformed input that cannot be
72/// decoded according to the crate's binary format.
73#[derive(Debug)]
74pub enum DeserializeError {
75    IO(std::io::Error),
76    InvalidBool(u8),
77    InvalidChar(u32),
78    IdentifierWasExpected,
79    AttemptToSkip,
80    AttemptToGetAny,
81    Custom(String),
82}
83
84impl Display for DeserializeError {
85    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
86        match self {
87            Self::IO(e) => write!(f, "{e}"),
88            Self::InvalidBool(v) => write!(f, "invalid bool {v}"),
89            Self::InvalidChar(v) => write!(f, "invalid char {v}"),
90            Self::IdentifierWasExpected => write!(
91                f,
92                "an identifier was expected but the `Serializer` doesn't write it"
93            ),
94            Self::AttemptToSkip => write!(f, "attempt to skip, but it is impossible"),
95            Self::AttemptToGetAny => write!(f, "attempt to get any, but it is impossible"),
96            Self::Custom(s) => write!(f, "{s}"),
97        }
98    }
99}
100
101impl std::error::Error for DeserializeError {}
102
103impl de::Error for DeserializeError {
104    fn custom<T: Display>(msg: T) -> Self {
105        Self::Custom(msg.to_string())
106    }
107}
108
109impl<'de, Src: Read> de::Deserializer<'de> for &mut RWDeserializer<Src> {
110    type Error = DeserializeError;
111
112    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
113    where
114        V: Visitor<'de>,
115    {
116        let mut b = [0];
117
118        self.source
119            .read_exact(&mut b)
120            .map_err(DeserializeError::IO)?;
121
122        match b[0] {
123            0 => visitor.visit_bool(false),
124            1 => visitor.visit_bool(true),
125            x => Err(DeserializeError::InvalidBool(x)),
126        }
127    }
128
129    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
130    where
131        V: Visitor<'de>,
132    {
133        visitor.visit_i8(self.source.read_varint().map_err(DeserializeError::IO)?)
134    }
135
136    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
137    where
138        V: Visitor<'de>,
139    {
140        visitor.visit_i16(self.source.read_varint().map_err(DeserializeError::IO)?)
141    }
142
143    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
144    where
145        V: Visitor<'de>,
146    {
147        visitor.visit_i32(self.source.read_varint().map_err(DeserializeError::IO)?)
148    }
149
150    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
151    where
152        V: Visitor<'de>,
153    {
154        visitor.visit_i64(self.source.read_varint().map_err(DeserializeError::IO)?)
155    }
156
157    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
158    where
159        V: Visitor<'de>,
160    {
161        visitor.visit_i128(self.source.read_varint().map_err(DeserializeError::IO)?)
162    }
163
164    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
165    where
166        V: Visitor<'de>,
167    {
168        visitor.visit_u8(self.source.read_varint().map_err(DeserializeError::IO)?)
169    }
170
171    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
172    where
173        V: Visitor<'de>,
174    {
175        visitor.visit_u16(self.source.read_varint().map_err(DeserializeError::IO)?)
176    }
177
178    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
179    where
180        V: Visitor<'de>,
181    {
182        visitor.visit_u32(self.source.read_varint().map_err(DeserializeError::IO)?)
183    }
184
185    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
186    where
187        V: Visitor<'de>,
188    {
189        visitor.visit_u64(self.source.read_varint().map_err(DeserializeError::IO)?)
190    }
191
192    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
193    where
194        V: Visitor<'de>,
195    {
196        visitor.visit_u128(self.source.read_varint().map_err(DeserializeError::IO)?)
197    }
198
199    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
200    where
201        V: Visitor<'de>,
202    {
203        let mut buf = [0; 4];
204
205        self.source
206            .read_exact(&mut buf)
207            .map_err(DeserializeError::IO)?;
208
209        visitor.visit_f32(f32::from_le_bytes(buf))
210    }
211
212    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
213    where
214        V: Visitor<'de>,
215    {
216        let mut buf = [0; 8];
217
218        self.source
219            .read_exact(&mut buf)
220            .map_err(DeserializeError::IO)?;
221
222        visitor.visit_f64(f64::from_le_bytes(buf))
223    }
224
225    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
226    where
227        V: Visitor<'de>,
228    {
229        let mut buf = [0; 4];
230        self.source
231            .read_exact(&mut buf)
232            .map_err(DeserializeError::IO)?;
233
234        let c = u32::from_le_bytes(buf);
235
236        char::from_u32(c).map_or_else(
237            || Err(DeserializeError::InvalidChar(c)),
238            |c| visitor.visit_char(c),
239        )
240    }
241
242    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
243    where
244        V: Visitor<'de>,
245    {
246        let len: u64 = self.source.read_varint().map_err(DeserializeError::IO)?;
247        let buf: SmallString<1024> = SmallString::fill_from_reader(
248            &mut self.source,
249            usize::try_from(len).expect("Length overflow"),
250        )
251        .map_err(DeserializeError::IO)?;
252
253        visitor.visit_str(&buf)
254    }
255
256    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
257    where
258        V: Visitor<'de>,
259    {
260        self.deserialize_string(visitor)
261    }
262
263    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
264    where
265        V: Visitor<'de>,
266    {
267        let len: u64 = self.source.read_varint().map_err(DeserializeError::IO)?;
268        let mut buf =
269            SmallVec::<u8, 1024>::with_capacity(usize::try_from(len).expect("Length overflow"));
270
271        self.source
272            .read_exact(&mut buf)
273            .map_err(DeserializeError::IO)?;
274
275        visitor.visit_bytes(&buf)
276    }
277
278    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
279    where
280        V: Visitor<'de>,
281    {
282        let len: u64 = self.source.read_varint().map_err(DeserializeError::IO)?;
283        let mut buf = Vec::with_capacity(usize::try_from(len).expect("Length overflow"));
284
285        #[allow(clippy::uninit_vec, reason = "We will imediatly fill it.")]
286        unsafe {
287            buf.set_len(buf.capacity())
288        };
289
290        #[allow(clippy::read_zero_byte_vec, reason = "False positive.")]
291        self.source
292            .read_exact(&mut buf)
293            .map_err(DeserializeError::IO)?;
294
295        visitor.visit_byte_buf(buf)
296    }
297
298    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
299    where
300        V: Visitor<'de>,
301    {
302        let exists: bool = self
303            .source
304            .read_varint::<u8>()
305            .map_err(DeserializeError::IO)?
306            > 0u8;
307
308        if exists {
309            visitor.visit_some(self)
310        } else {
311            visitor.visit_none()
312        }
313    }
314
315    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
316    where
317        V: Visitor<'de>,
318    {
319        let len: u64 = self.source.read_varint().map_err(DeserializeError::IO)?;
320
321        visitor.visit_seq(Access {
322            de: self,
323            remaining: usize::try_from(len).expect("Length overflow"),
324        })
325    }
326
327    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
328    where
329        V: Visitor<'de>,
330    {
331        visitor.visit_seq(Access {
332            de: self,
333            remaining: len,
334        })
335    }
336
337    fn deserialize_tuple_struct<V>(
338        self,
339        _name: &'static str,
340        len: usize,
341        visitor: V,
342    ) -> Result<V::Value, Self::Error>
343    where
344        V: Visitor<'de>,
345    {
346        visitor.visit_seq(Access {
347            de: self,
348            remaining: len,
349        })
350    }
351
352    fn deserialize_newtype_struct<V>(
353        self,
354        _name: &'static str,
355        visitor: V,
356    ) -> Result<V::Value, Self::Error>
357    where
358        V: Visitor<'de>,
359    {
360        visitor.visit_newtype_struct(self)
361    }
362
363    fn deserialize_struct<V>(
364        self,
365        _name: &'static str,
366        fields: &'static [&'static str],
367        visitor: V,
368    ) -> Result<V::Value, Self::Error>
369    where
370        V: Visitor<'de>,
371    {
372        visitor.visit_seq(Access {
373            de: self,
374            remaining: fields.len(),
375        })
376    }
377
378    fn deserialize_unit_struct<V>(
379        self,
380        _name: &'static str,
381        visitor: V,
382    ) -> Result<V::Value, Self::Error>
383    where
384        V: Visitor<'de>,
385    {
386        visitor.visit_unit()
387    }
388
389    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
390    where
391        V: Visitor<'de>,
392    {
393        visitor.visit_unit()
394    }
395
396    fn deserialize_enum<V>(
397        self,
398        _name: &'static str,
399        _variants: &'static [&'static str],
400        visitor: V,
401    ) -> Result<V::Value, Self::Error>
402    where
403        V: Visitor<'de>,
404    {
405        let variant: u32 = self.source.read_varint().map_err(DeserializeError::IO)?;
406
407        visitor.visit_enum(EnumAccessImpl { de: self, variant })
408    }
409
410    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
411    where
412        V: Visitor<'de>,
413    {
414        let len: u64 = self.source.read_varint().map_err(DeserializeError::IO)?;
415
416        visitor.visit_map(MapAccessImpl {
417            de: self,
418            remaining: usize::try_from(len).expect("Length overflow"),
419        })
420    }
421
422    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
423    where
424        V: Visitor<'de>,
425    {
426        Err(DeserializeError::AttemptToGetAny)
427    }
428
429    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
430    where
431        V: Visitor<'de>,
432    {
433        Err(DeserializeError::IdentifierWasExpected)
434    }
435
436    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
437    where
438        V: Visitor<'de>,
439    {
440        Err(DeserializeError::AttemptToSkip)
441    }
442
443    fn is_human_readable(&self) -> bool {
444        false
445    }
446}
447
448struct Access<'a, Src: Read> {
449    de: &'a mut RWDeserializer<Src>,
450    remaining: usize,
451}
452
453impl<'de, Src: Read> SeqAccess<'de> for Access<'_, Src> {
454    type Error = DeserializeError;
455
456    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
457    where
458        T: DeserializeSeed<'de>,
459    {
460        if self.remaining == 0 {
461            return Ok(None);
462        }
463
464        self.remaining -= 1;
465
466        seed.deserialize(&mut *self.de).map(Some)
467    }
468}
469
470struct EnumAccessImpl<'a, Src: Read> {
471    de: &'a mut RWDeserializer<Src>,
472    variant: u32,
473}
474
475impl<'de, Src: Read> EnumAccess<'de> for EnumAccessImpl<'_, Src> {
476    type Error = DeserializeError;
477    type Variant = Self;
478
479    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
480    where
481        V: DeserializeSeed<'de>,
482    {
483        let value = seed.deserialize(self.variant.into_deserializer())?;
484
485        Ok((value, self))
486    }
487}
488
489impl<'de, Src: Read> VariantAccess<'de> for EnumAccessImpl<'_, Src> {
490    type Error = DeserializeError;
491
492    fn unit_variant(self) -> Result<(), Self::Error> {
493        Ok(())
494    }
495
496    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
497    where
498        T: DeserializeSeed<'de>,
499    {
500        seed.deserialize(self.de)
501    }
502
503    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
504    where
505        V: Visitor<'de>,
506    {
507        de::Deserializer::deserialize_tuple(self.de, len, visitor)
508    }
509
510    fn struct_variant<V>(
511        self,
512        fields: &'static [&'static str],
513        visitor: V,
514    ) -> Result<V::Value, Self::Error>
515    where
516        V: Visitor<'de>,
517    {
518        de::Deserializer::deserialize_tuple(self.de, fields.len(), visitor)
519    }
520}
521
522struct MapAccessImpl<'a, Src: Read> {
523    de: &'a mut RWDeserializer<Src>,
524    remaining: usize,
525}
526
527impl<'de, Src: Read> MapAccess<'de> for MapAccessImpl<'_, Src> {
528    type Error = DeserializeError;
529
530    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
531    where
532        K: DeserializeSeed<'de>,
533    {
534        if self.remaining == 0 {
535            return Ok(None);
536        }
537
538        seed.deserialize(&mut *self.de).map(Some)
539    }
540
541    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
542    where
543        V: DeserializeSeed<'de>,
544    {
545        self.remaining -= 1;
546
547        seed.deserialize(&mut *self.de)
548    }
549
550    fn size_hint(&self) -> Option<usize> {
551        Some(self.remaining)
552    }
553}
554
555#[cfg(test)]
556mod tests {
557    use super::*;
558    use crate::rw_serde::RWSerializer;
559    use serde::{Deserialize, Serialize};
560    use std::io::Cursor;
561
562    fn serializer() -> RWSerializer<Vec<u8>> {
563        RWSerializer::new(Vec::new())
564    }
565
566    #[test]
567    fn deserialize_primitives() {
568        #[derive(Serialize, Deserialize, PartialEq, Debug)]
569        struct A {
570            u8: u8,
571            i8: i8,
572            u16: u16,
573            bool_2: bool,
574            i16: i16,
575            f64_2: f64,
576            char_2: char,
577            u32: u32,
578            i32: i32,
579            u64: u64,
580            i64: i64,
581            u8_2: u8,
582            i8_2: i8,
583            u16_2: u16,
584            i16_2: i16,
585            f32: f32,
586            f64: f64,
587            bool: bool,
588            char: char,
589            u32_2: u32,
590            i32_2: i32,
591            u64_2: u64,
592            i64_2: i64,
593            f32_2: f32,
594        }
595
596        let obj = A {
597            u8: 1,
598            i8: 2,
599            u16: 3,
600            bool_2: true,
601            i16: 4,
602            f64_2: 5.0,
603            char_2: 'c',
604            u32: 6,
605            i32: 7,
606            u64: 8,
607            i64: 9,
608            u8_2: 10,
609            i8_2: 11,
610            u16_2: 12,
611            i16_2: 13,
612            f32: 14.0,
613            f64: 15.0,
614            bool: false,
615            char: 'd',
616            u32_2: 16,
617            i32_2: 17,
618            u64_2: 2018,
619            i64_2: 2019,
620            f32_2: 20.0,
621        };
622
623        let mut ser = serializer();
624        let written = obj.serialize(&mut ser).unwrap();
625
626        let buf = ser.into_inner();
627
628        assert_eq!(buf.len(), 52);
629        assert_eq!(buf.len(), written);
630
631        let mut de = RWDeserializer::new(Cursor::new(buf));
632        let deserialized = A::deserialize(&mut de).unwrap();
633
634        assert_eq!(obj, deserialized);
635    }
636
637    #[test]
638    fn serialize_string() {
639        #[derive(Serialize, Deserialize, PartialEq, Debug)]
640        struct A {
641            value: String,
642        }
643
644        let obj = A {
645            value: "Hello, world!".into(),
646        };
647
648        let mut ser = serializer();
649        let written = obj.serialize(&mut ser).unwrap();
650
651        let buf = ser.into_inner();
652
653        assert_eq!(buf.len(), 14);
654        assert_eq!(buf.len(), written);
655
656        let mut de = RWDeserializer::new(Cursor::new(buf));
657        let out = A::deserialize(&mut de).unwrap();
658
659        assert_eq!(obj, out);
660    }
661
662    #[test]
663    fn serialize_vec() {
664        #[derive(Serialize, Deserialize, PartialEq, Debug)]
665        struct A {
666            a: Vec<u32>,
667            b: Vec<Vec<String>>,
668        }
669
670        let obj = A {
671            a: vec![1, 2, 3, 4, 5],
672            b: vec![
673                vec![String::from("hello"), String::from("world")],
674                vec![String::from("foo"), String::from("bar")],
675            ],
676        };
677
678        let mut ser = serializer();
679        let written = obj.serialize(&mut ser).unwrap();
680
681        let buf = ser.into_inner();
682
683        assert_eq!(buf.len(), 6 + 23);
684        assert_eq!(buf.len(), written);
685
686        let mut de = RWDeserializer::new(Cursor::new(buf));
687        let out = A::deserialize(&mut de).unwrap();
688
689        assert_eq!(obj, out);
690    }
691
692    #[test]
693    fn serialize_some() {
694        #[derive(Serialize, Deserialize, PartialEq, Debug)]
695        struct A {
696            a: Option<u32>,
697            b: Option<u32>,
698            c: Option<String>,
699            d: Option<String>,
700        }
701
702        let obj = A {
703            a: Some(42),
704            b: None,
705            c: None,
706            d: Some("hello".into()),
707        };
708
709        let mut ser = serializer();
710        let written = obj.serialize(&mut ser).unwrap();
711
712        let buf = ser.into_inner();
713
714        assert_eq!(buf.len(), 11);
715        assert_eq!(buf.len(), written);
716
717        let mut de = RWDeserializer::new(Cursor::new(buf));
718        let out = A::deserialize(&mut de).unwrap();
719
720        assert_eq!(obj, out);
721    }
722
723    #[test]
724    fn serialize_nested_structs() {
725        #[derive(Serialize, Deserialize, PartialEq, Debug)]
726        struct Inner {
727            x: u32,
728            y: String,
729        }
730
731        #[derive(Serialize, Deserialize, PartialEq, Debug)]
732        struct Outer {
733            a: Inner,
734            b: Inner,
735        }
736
737        let obj = Outer {
738            a: Inner {
739                x: 42,
740                y: "hello".into(),
741            },
742            b: Inner {
743                x: 100,
744                y: "world".into(),
745            },
746        };
747
748        let mut ser = serializer();
749        let written = obj.serialize(&mut ser).unwrap();
750
751        let buf = ser.into_inner();
752
753        assert_eq!(buf.len(), 14);
754        assert_eq!(buf.len(), written);
755
756        let mut de = RWDeserializer::new(Cursor::new(buf));
757        let out = Outer::deserialize(&mut de).unwrap();
758
759        assert_eq!(obj, out);
760    }
761
762    #[test]
763    fn serialize_tuple_struct() {
764        #[derive(Serialize, Deserialize, PartialEq, Debug)]
765        struct A(u32, String, bool);
766
767        let obj = A(123, "hello".into(), true);
768
769        let mut ser = serializer();
770        let written = obj.serialize(&mut ser).unwrap();
771
772        let buf = ser.into_inner();
773
774        assert_eq!(buf.len(), 8);
775        assert_eq!(buf.len(), written);
776
777        let mut de = RWDeserializer::new(Cursor::new(buf));
778        let out = A::deserialize(&mut de).unwrap();
779
780        assert_eq!(obj, out);
781    }
782
783    #[test]
784    fn serialize_newtype_struct() {
785        #[derive(Serialize, Deserialize, PartialEq, Debug)]
786        struct Id(u64);
787
788        let obj = Id(999);
789
790        let mut ser = serializer();
791        let written = obj.serialize(&mut ser).unwrap();
792
793        let buf = ser.into_inner();
794
795        assert_eq!(buf.len(), 2);
796        assert_eq!(buf.len(), written);
797
798        let mut de = RWDeserializer::new(Cursor::new(buf));
799        let out = Id::deserialize(&mut de).unwrap();
800
801        assert_eq!(obj, out);
802    }
803
804    #[test]
805    fn serialize_unit_struct() {
806        #[derive(Serialize, Deserialize, PartialEq, Debug)]
807        struct Marker;
808
809        let obj = Marker;
810
811        let mut ser = serializer();
812        let written = obj.serialize(&mut ser).unwrap();
813
814        let buf = ser.into_inner();
815
816        assert_eq!(buf.len(), 0);
817        assert_eq!(buf.len(), written);
818
819        let mut de = RWDeserializer::new(Cursor::new(buf));
820        let out = Marker::deserialize(&mut de).unwrap();
821
822        assert_eq!(obj, out);
823    }
824
825    #[test]
826    fn serialize_enum() {
827        #[derive(Serialize, Deserialize, PartialEq, Debug)]
828        enum E {
829            Unit,
830            NewType(u32),
831            Tuple(u32, String),
832            Struct { id: u64, name: String },
833        }
834
835        let values = [
836            (E::Unit, 1),
837            (E::NewType(42), 2),
838            (E::Tuple(1, "hello".into()), 8),
839            (
840                E::Struct {
841                    id: 99,
842                    name: "world".into(),
843                },
844                8,
845            ),
846        ];
847
848        for (value, expected_size) in values {
849            let mut ser = serializer();
850            let written = value.serialize(&mut ser).unwrap();
851
852            let buf = ser.into_inner();
853
854            assert_eq!(buf.len(), expected_size);
855            assert_eq!(buf.len(), written);
856
857            let mut de = RWDeserializer::new(Cursor::new(buf));
858            let out = E::deserialize(&mut de).unwrap();
859
860            assert_eq!(value, out);
861        }
862    }
863
864    #[test]
865    fn serialize_array() {
866        let obj = [1u16, 2, 3, 4, 5];
867
868        let mut ser = serializer();
869        let written = obj.serialize(&mut ser).unwrap();
870
871        let buf = ser.into_inner();
872
873        assert_eq!(buf.len(), 5);
874        assert_eq!(buf.len(), written);
875
876        let mut de = RWDeserializer::new(Cursor::new(buf));
877        let out = <[u16; 5]>::deserialize(&mut de).unwrap();
878
879        assert_eq!(obj, out);
880    }
881
882    #[test]
883    fn serialize_hashmap() {
884        use std::collections::HashMap;
885
886        #[derive(Serialize, Deserialize, PartialEq, Debug)]
887        struct A {
888            map: HashMap<String, u32>,
889        }
890
891        let mut map = HashMap::new();
892        map.insert("one".into(), 1);
893        map.insert("two".into(), 2);
894        map.insert("three".into(), 3);
895
896        let obj = A { map };
897
898        let mut ser = serializer();
899        let written = obj.serialize(&mut ser).unwrap();
900
901        let buf = ser.into_inner();
902
903        assert_eq!(buf.len(), 1 + 5 + 5 + 7);
904        assert_eq!(buf.len(), written);
905
906        let mut de = RWDeserializer::new(Cursor::new(buf));
907        let out = A::deserialize(&mut de).unwrap();
908
909        assert_eq!(obj, out);
910    }
911
912    #[test]
913    fn serialize_btreemap() {
914        use std::collections::BTreeMap;
915
916        #[derive(Serialize, Deserialize, PartialEq, Debug)]
917        struct A {
918            map: BTreeMap<String, u32>,
919        }
920
921        let mut map = BTreeMap::new();
922        map.insert("one".into(), 1);
923        map.insert("two".into(), 2);
924        map.insert("three".into(), 3);
925
926        let obj = A { map };
927
928        let mut ser = serializer();
929        let written = obj.serialize(&mut ser).unwrap();
930
931        let buf = ser.into_inner();
932
933        assert_eq!(buf.len(), 1 + 5 + 5 + 7);
934        assert_eq!(buf.len(), written);
935
936        let mut de = RWDeserializer::new(Cursor::new(buf));
937        let out = A::deserialize(&mut de).unwrap();
938
939        assert_eq!(obj, out);
940    }
941
942    #[test]
943    fn serialize_hashset() {
944        use std::collections::HashSet;
945
946        #[derive(Serialize, Deserialize, PartialEq, Debug)]
947        struct A {
948            values: HashSet<u32>,
949        }
950
951        let mut values = HashSet::new();
952        values.insert(1);
953        values.insert(2);
954        values.insert(3);
955
956        let obj = A { values };
957
958        let mut ser = serializer();
959        let written = obj.serialize(&mut ser).unwrap();
960
961        let buf = ser.into_inner();
962
963        assert_eq!(buf.len(), 4);
964        assert_eq!(buf.len(), written);
965
966        let mut de = RWDeserializer::new(Cursor::new(buf));
967        let out = A::deserialize(&mut de).unwrap();
968
969        assert_eq!(obj, out);
970    }
971
972    #[test]
973    fn serialize_vecdeque() {
974        use std::collections::VecDeque;
975
976        #[derive(Serialize, Deserialize, PartialEq, Debug)]
977        struct A {
978            values: VecDeque<u32>,
979        }
980
981        let obj = A {
982            values: VecDeque::from(vec![1, 2, 3, 4]),
983        };
984
985        let mut ser = serializer();
986        let written = obj.serialize(&mut ser).unwrap();
987
988        let buf = ser.into_inner();
989
990        assert_eq!(buf.len(), 5);
991        assert_eq!(buf.len(), written);
992
993        let mut de = RWDeserializer::new(Cursor::new(buf));
994        let out = A::deserialize(&mut de).unwrap();
995
996        assert_eq!(obj, out);
997    }
998}
orengine_utils/rw_serde/deserializer.rs

orengine_utils/rw_serde/
deserializer.rs
