rust_fr/
serializer.rs

1//! ### Serializer
2//! The module that handles the serialization of the data.
3//!
4//! To use the serializer, call the [`to_bytes`] function with a reference to the data to be
5//! serialized. The data must implement the `Serialize` trait from the `serde` library.
6
7use bitvec::{prelude as bv, slice::BitSlice};
8use serde::{
9    ser::{
10        SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
11        SerializeTupleStruct, SerializeTupleVariant,
12    },
13    Serialize, Serializer,
14};
15
16use super::error::Error;
17
18/// The delimiter used in the format specification. The purpose
19/// of delimiters is to separate different types of data such
20/// that they don't mangle. There are 8 different delimiters
21/// in the format specification out of which 3 (`String`, `Byte` & `Map`)
22/// are 1 byte long and 5 (the rest...) are 3 bits long.
23#[derive(Debug, Clone, PartialEq, Eq)]
24pub enum Delimiter {
25    // 0b10000110
26    String = 134,
27    // 0b10000111
28    Byte = 135,
29    // 0b010
30    Unit = 2,
31    // 0b011
32    Seq = 3,
33    // 0b100
34    SeqValue = 4,
35    // 0b10001011
36    Map = 139,
37    // 0b110
38    MapKey = 6,
39    // 0b111
40    MapValue = 7,
41}
42
43impl std::fmt::Display for Delimiter {
44    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
45        match self {
46            Delimiter::String => write!(f, "String"),
47            Delimiter::Byte => write!(f, "Byte"),
48            Delimiter::Unit => write!(f, "Unit"),
49            Delimiter::Seq => write!(f, "Seq"),
50            Delimiter::SeqValue => write!(f, "SeqValue"),
51            Delimiter::Map => write!(f, "Map"),
52            Delimiter::MapKey => write!(f, "MapKey"),
53            Delimiter::MapValue => write!(f, "MapValue"),
54        }
55    }
56}
57
58// Internal struct that handles the serialization of the data.
59// It has a few methods that lets us peeking bytes in the data.
60#[derive(Debug)]
61struct CustomSerializer {
62    data: bv::BitVec<u8, bv::Lsb0>,
63}
64
65/// The function to serialize data of a given type to a byte vector. The
66/// `value` must implement the `Serialize` trait from the `serde` library. It returns
67/// a Result with the serialized byte vector or an error.
68pub fn to_bytes<T: Serialize>(value: &T) -> Result<Vec<u8>, Error> {
69    let mut serializer = CustomSerializer {
70        data: bv::BitVec::new(),
71    };
72    value.serialize(&mut serializer)?;
73    Ok(serializer.data.into_vec())
74}
75
76impl CustomSerializer {
77    /// Get 'n' bits from end of the data.
78    fn _peek_n_bits(&self, size: usize) -> Result<&BitSlice<u8>, Error> {
79        let len = self.data.len();
80        if size > len {
81            return Err(Error::NLargerThanLength(size, self.data.len()));
82        }
83        self.data.get(len - size..).ok_or(Error::NoByte)
84    }
85
86    /// Construst a byte from the last 3 bits of the data.
87    pub fn peek_token(&self, token: Delimiter) -> Result<bool, Error> {
88        let bits = match token {
89            Delimiter::String => self._peek_n_bits(8)?,
90            Delimiter::Byte => self._peek_n_bits(8)?,
91            Delimiter::Map => self._peek_n_bits(8)?,
92            _ => self._peek_n_bits(3)?,
93        };
94        let mut byte = 0u8;
95        for (i, bit) in bits.iter().enumerate() {
96            if *bit {
97                byte |= 1 << i;
98            }
99        }
100        Ok(byte == token as u8)
101    }
102
103    /// Get token before 'n' bits.
104    pub fn peek_token_before_n_bits(&self, n: usize) -> Result<u8, Error> {
105        let bits = self._peek_n_bits(n + 3)?[0..3].as_ref();
106        let mut byte = 0u8;
107        for (i, bit) in bits.iter().enumerate() {
108            if *bit {
109                byte |= 1 << i;
110            }
111        }
112        Ok(byte)
113    }
114
115    /// Serialize a token to the data.
116    pub fn serialize_token(&mut self, token: Delimiter) {
117        match token {
118            Delimiter::String => {
119                self.data
120                    .extend(&[false, true, true, false, false, false, false, true]);
121                // 10000110
122            }
123            Delimiter::Byte => {
124                self.data
125                    .extend(&[true, true, true, false, false, false, false, true]);
126                // 10000111
127            }
128            Delimiter::Unit => {
129                self.data.extend(&[false, true, false]); // 010
130            }
131            Delimiter::Seq => {
132                self.data.extend(&[true, true, false]); // 011
133            }
134            Delimiter::SeqValue => {
135                self.data.extend(&[false, false, true]); // 100
136            }
137            Delimiter::Map => {
138                self.data
139                    .extend(&[true, true, false, true, false, false, false, true]);
140                // 10001011
141            }
142            Delimiter::MapKey => {
143                self.data.extend(&[false, true, true]); // 110
144            }
145            Delimiter::MapValue => {
146                self.data.extend(&[true, true, true]); // 111
147            }
148        }
149    }
150}
151
152impl<'a> Serializer for &'a mut CustomSerializer {
153    type Ok = ();
154    type Error = Error;
155
156    type SerializeSeq = Self;
157    type SerializeMap = Self;
158
159    type SerializeTuple = Self;
160    type SerializeStruct = Self;
161
162    type SerializeTupleStruct = Self;
163    type SerializeTupleVariant = Self;
164    type SerializeStructVariant = Self;
165
166    /// bool: 0 -> false, 1 -> true (1 bit)
167    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
168        self.data.push(v);
169        Ok(())
170    }
171
172    /// i8, i16, i32, i64: Little Endian (1, 2, 4, 8 bytes)
173    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
174        self.data.extend(&v.to_le_bytes());
175        Ok(())
176    }
177    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
178        self.data.extend(&v.to_le_bytes());
179        Ok(())
180    }
181    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
182        self.data.extend(&v.to_le_bytes());
183        Ok(())
184    }
185    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
186        self.data.extend(&v.to_le_bytes());
187        Ok(())
188    }
189
190    /// u8, u16, u32, u64: Little Endian (1, 2, 4, 8 bytes)
191    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
192        self.data.extend(&v.to_le_bytes());
193        Ok(())
194    }
195    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
196        self.data.extend(&v.to_le_bytes());
197        Ok(())
198    }
199    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
200        self.data.extend(&v.to_le_bytes());
201        Ok(())
202    }
203    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
204        self.data.extend(&v.to_le_bytes());
205        Ok(())
206    }
207
208    /// f32, f64: Little Endian (4, 8 bytes)
209    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
210        self.data.extend(&v.to_le_bytes());
211        Ok(())
212    }
213    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
214        self.data.extend(&v.to_le_bytes());
215        Ok(())
216    }
217
218    /// char: as u32 (4 bytes)
219    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
220        self.serialize_u32(u32::from(v))
221    }
222    /// str: bytes STRING_DELIMITER
223    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
224        self.data.extend(v.as_bytes());
225        self.serialize_token(Delimiter::String);
226        Ok(())
227    }
228    /// bytes: bytes BYTE_DELIMITER
229    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
230        self.data.extend(v);
231        self.serialize_token(Delimiter::Byte);
232        Ok(())
233    }
234
235    /// unit: UNIT (null)
236    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
237        self.serialize_token(Delimiter::Unit);
238        Ok(())
239    }
240
241    /// option:
242    /// None -> unit()
243    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
244        self.serialize_unit()
245    }
246    /// Some -> self
247    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
248    where
249        T: Serialize,
250    {
251        value.serialize(self)
252    }
253
254    /// structs:
255    /// unit_struct: unit()
256    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
257        self.serialize_unit()
258    }
259    /// newtype_struct: self
260    fn serialize_newtype_struct<T: ?Sized>(
261        self,
262        _name: &'static str,
263        value: &T,
264    ) -> Result<Self::Ok, Self::Error>
265    where
266        T: Serialize,
267    {
268        value.serialize(self)
269    }
270    /// tuple_struct: tuple()
271    fn serialize_tuple_struct(
272        self,
273        _name: &'static str,
274        len: usize,
275    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
276        self.serialize_tuple(len)
277    }
278
279    /// enum:
280    /// unit_variant: variant_index
281    fn serialize_unit_variant(
282        self,
283        _name: &'static str,
284        variant_index: u32,
285        _variant: &'static str,
286    ) -> Result<Self::Ok, Self::Error> {
287        self.serialize_u32(variant_index)
288    }
289    /// newtype_variant: variant_index self
290    fn serialize_newtype_variant<T: ?Sized>(
291        self,
292        _name: &'static str,
293        variant_index: u32,
294        _variant: &'static str,
295        value: &T,
296    ) -> Result<Self::Ok, Self::Error>
297    where
298        T: Serialize,
299    {
300        self.serialize_u32(variant_index)?;
301        value.serialize(self)
302    }
303    /// tuple_variant: variant_index tuple()
304    fn serialize_tuple_variant(
305        self,
306        _name: &'static str,
307        variant_index: u32,
308        _variant: &'static str,
309        len: usize,
310    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
311        self.serialize_u32(variant_index)?;
312        self.serialize_seq(Some(len))
313    }
314    /// struct_variant: variant_index struct()
315    fn serialize_struct_variant(
316        self,
317        _name: &'static str,
318        variant_index: u32,
319        _variant: &'static str,
320        len: usize,
321    ) -> Result<Self::SerializeStructVariant, Self::Error> {
322        self.serialize_u32(variant_index)?;
323        self.serialize_map(Some(len))
324    }
325
326    /// sequences: SEQ_DELIMITER + value_1 + SEQ_VALUE_DELIMITER + value_2 + SEQ_VALUE_DELIMITER + ... SEQ_DELIMITER
327    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
328        self.serialize_token(Delimiter::Seq);
329        Ok(self)
330    }
331    /// maps: key_1 + MAP_KEY_DELIMITER + value_1 + MAP_VALUE_DELIMITER + key_2 + MAP_KEY_DELIMITER + value_2 + MAP_VALUE_DELIMITER +... MAP_DELIMITER
332    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
333        Ok(self)
334    }
335
336    /// tuples: seq()
337    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
338        self.serialize_seq(Some(len))
339    }
340    /// structs: map()
341    fn serialize_struct(
342        self,
343        _name: &'static str,
344        len: usize,
345    ) -> Result<Self::SerializeStruct, Self::Error> {
346        self.serialize_map(Some(len))
347    }
348}
349
350impl<'a> SerializeSeq for &'a mut CustomSerializer {
351    type Ok = ();
352    type Error = Error;
353
354    /// Serialize an element of the sequence.
355    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
356    where
357        T: Serialize,
358    {
359        if !self.peek_token(Delimiter::Seq)? {
360            self.serialize_token(Delimiter::SeqValue);
361        }
362        value.serialize(&mut **self)
363    }
364
365    fn end(self) -> Result<Self::Ok, Self::Error> {
366        self.serialize_token(Delimiter::Seq);
367        Ok(())
368    }
369}
370impl<'a> SerializeMap for &'a mut CustomSerializer {
371    type Ok = ();
372    type Error = Error;
373
374    /// Serialize a key of a given element of the map.
375    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
376    where
377        T: Serialize,
378    {
379        key.serialize(&mut **self)?;
380        self.serialize_token(Delimiter::MapKey);
381        Ok(())
382    }
383
384    /// Serialize a value of a given element of the map.
385    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
386    where
387        T: Serialize,
388    {
389        value.serialize(&mut **self)?;
390        self.serialize_token(Delimiter::MapValue);
391        Ok(())
392    }
393
394    /// End the map serialization.
395    fn end(self) -> Result<Self::Ok, Self::Error> {
396        self.serialize_token(Delimiter::Map);
397        Ok(())
398    }
399}
400
401// = seq()
402impl<'a> SerializeTuple for &'a mut CustomSerializer {
403    type Ok = ();
404    type Error = Error;
405
406    /// Serialize an element of the tuple.
407    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
408    where
409        T: Serialize,
410    {
411        if !self.peek_token(Delimiter::Seq)? {
412            self.serialize_token(Delimiter::SeqValue);
413        }
414        value.serialize(&mut **self)
415    }
416
417    /// End the tuple serialization.
418    fn end(self) -> Result<Self::Ok, Self::Error> {
419        self.serialize_token(Delimiter::Seq);
420        Ok(())
421    }
422}
423// = map()
424impl<'a> SerializeStruct for &'a mut CustomSerializer {
425    type Ok = ();
426    type Error = Error;
427
428    /// Serialize a field of the struct. Structs treated as a key-value pair i.e. a map.
429    /// There is no difference between a struct and a map in the serialization format.
430    fn serialize_field<T: ?Sized>(
431        &mut self,
432        key: &'static str,
433        value: &T,
434    ) -> Result<(), Self::Error>
435    where
436        T: Serialize,
437    {
438        key.serialize(&mut **self)?;
439        self.serialize_token(Delimiter::MapKey);
440        value.serialize(&mut **self)?;
441        self.serialize_token(Delimiter::MapValue);
442        Ok(())
443    }
444
445    /// End the struct serialization.
446    fn end(self) -> Result<Self::Ok, Self::Error> {
447        self.serialize_token(Delimiter::Map);
448        Ok(())
449    }
450}
451
452// = seq()
453impl<'a> SerializeTupleStruct for &'a mut CustomSerializer {
454    type Ok = ();
455    type Error = Error;
456
457    /// Serialize an element of the tuple. Tuple structs treated as a sequence.
458    /// There is no difference between a tuple struct and a sequence in the serialization format.
459    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
460    where
461        T: Serialize,
462    {
463        if !self.peek_token(Delimiter::Seq)? {
464            self.serialize_token(Delimiter::SeqValue);
465        }
466        value.serialize(&mut **self)
467    }
468
469    /// End the tuple struct serialization.
470    fn end(self) -> Result<Self::Ok, Self::Error> {
471        self.serialize_token(Delimiter::Seq);
472        Ok(())
473    }
474}
475
476// = tuple() = seq()
477impl<'a> SerializeTupleVariant for &'a mut CustomSerializer {
478    type Ok = ();
479    type Error = Error;
480
481    /// Serialize an element of the tuple in an enum variant. Tuple variants treated as a sequence.
482    /// There is no difference between a tuple variant and a sequence in the serialization format.
483    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
484    where
485        T: Serialize,
486    {
487        if self.peek_token_before_n_bits(32)? != Delimiter::Seq as u8 {
488            self.serialize_token(Delimiter::SeqValue);
489        }
490        value.serialize(&mut **self)
491    }
492
493    /// End the tuple variant serialization.
494    fn end(self) -> Result<Self::Ok, Self::Error> {
495        self.serialize_token(Delimiter::Seq);
496        Ok(())
497    }
498}
499
500// = struct() = map()
501impl<'a> SerializeStructVariant for &'a mut CustomSerializer {
502    type Ok = ();
503    type Error = Error;
504
505    /// Serialize a field of the struct in an enum variant. Struct variants treated as a key-value pair i.e. a map.
506    /// There is no difference between a struct variant and a map in the serialization format.
507    fn serialize_field<T: ?Sized>(
508        &mut self,
509        key: &'static str,
510        value: &T,
511    ) -> Result<(), Self::Error>
512    where
513        T: Serialize,
514    {
515        key.serialize(&mut **self)?;
516        self.serialize_token(Delimiter::MapKey);
517        value.serialize(&mut **self)?;
518        self.serialize_token(Delimiter::MapValue);
519        Ok(())
520    }
521
522    /// End the struct variant serialization.
523    fn end(self) -> Result<Self::Ok, Self::Error> {
524        self.serialize_token(Delimiter::Map);
525        Ok(())
526    }
527}
rust_fr/serializer.rs

rust_fr/
serializer.rs
