rust_fr/
deserializer.rs

1//! ### Deserializer
2//! This module contains the deserialization logic for the library. It is used to deserialize
3//! bytes to a custom type.
4//!
5//! To use the deserializer, you need to call the [`from_bytes`] function which takes in
6//! the bytes and a type. The type must implement the `Deserialize` trait from the serde library.
7//! It returns a Result with the deserialized data or an error.
8
9use bitvec::{prelude as bv, slice::BitSlice, view::BitView};
10use serde::{
11    de::{EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess},
12    Deserialize, Deserializer,
13};
14
15use super::{error::Error, serializer::Delimiter};
16
17// Internal struct that handles the deserialization of the data.
18// It has a few methods that allows us to peek and eat bytes from the data.
19// It also has methods to parse some data into the required type.
20#[derive(Debug)]
21struct CustomDeserializer<'de> {
22    data: &'de bv::BitSlice<u8, bv::Lsb0>,
23}
24
25/// The function to deserialize (serialized) bytes back into data. `T` must implement the `Deserialize` trait
26/// from the `serde` library. `bytes` is the data to be deserialized. It returns a Result with the deserialized
27/// data or an error.
28pub fn from_bytes<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
29where
30    T: Deserialize<'de>,
31{
32    let mut deserializer = CustomDeserializer {
33        data: bytes.view_bits(),
34    };
35    let deserialized = T::deserialize(&mut deserializer)?;
36    Ok(deserialized)
37}
38
39impl<'de> CustomDeserializer<'de> {
40    /// Get 'n' bits from end of the data.
41    /// Example: If the data is 0b10101010 and n is 3, the result will be 0b010.
42    fn _peek_n_bits(&self, size: usize) -> Result<&BitSlice<u8>, Error> {
43        let len = self.data.len();
44        if size > len {
45            return Err(Error::NLargerThanLength(size, self.data.len()));
46        }
47        self.data.get(..size).ok_or(Error::NoByte)
48    }
49
50    /// Get the first byte from the data.
51    pub fn peek_byte(&self) -> Result<u8, Error> {
52        let bits = self._peek_n_bits(8)?;
53        let mut byte = 0u8;
54        for (i, bit) in bits.iter().enumerate() {
55            if *bit {
56                byte |= 1 << i;
57            }
58        }
59        Ok(byte)
60    }
61
62    /// Peek the next token from the data.
63    pub fn peek_token(&self, token: Delimiter) -> Result<bool, Error> {
64        let bits = match token {
65            Delimiter::String => self._peek_n_bits(8)?,
66            Delimiter::Byte => self._peek_n_bits(8)?,
67            Delimiter::Map => self._peek_n_bits(8)?,
68            _ => self._peek_n_bits(3)?,
69        };
70        let mut byte = 0u8;
71        for (i, bit) in bits.iter().enumerate() {
72            if *bit {
73                byte |= 1 << i;
74            }
75        }
76        if byte == token as u8 {
77            Ok(true)
78        } else {
79            Ok(false)
80        }
81    }
82
83    /// Grab the next bit from the data and remove it.
84    pub fn eat_bit(&mut self) -> Result<bool, Error> {
85        let bit = *self._peek_n_bits(1)?.get(0).ok_or(Error::NoBit)?;
86        self.data = &self.data[1..];
87        Ok(bit)
88    }
89
90    /// Grab the next byte from the data and remove it.
91    pub fn eat_byte(&mut self) -> Result<u8, Error> {
92        let byte = self.peek_byte()?;
93        self.data = &self.data[8..];
94        Ok(byte)
95    }
96
97    /// Grab the next 'n' bytes from the data and remove them.
98    pub fn eat_bytes(&mut self, n: usize) -> Result<Vec<u8>, Error> {
99        let bits = &self.data[..n * 8];
100        let mut bytes = Vec::new();
101        self.data = &self.data[n * 8..];
102        for i in 0..n {
103            let mut byte = 0u8;
104            for (j, bit) in bits[i * 8..(i + 1) * 8].iter().enumerate() {
105                if *bit {
106                    byte |= 1 << j;
107                }
108            }
109            bytes.push(byte);
110        }
111        Ok(bytes)
112    }
113
114    /// Grab the next token from the data and remove it.
115    pub fn eat_token(&mut self, token: Delimiter) -> Result<(), Error> {
116        let bits_to_munch = match token {
117            Delimiter::String => 8,
118            Delimiter::Byte => 8,
119            Delimiter::Map => 8,
120            _ => 3,
121        };
122        if self.data.len() < bits_to_munch {
123            return Err(Error::UnexpectedEOF);
124        }
125        self.data = &self.data[bits_to_munch..];
126        Ok(())
127    }
128
129    /// Parser Methods
130
131    /// Parses a boolean value from the input.
132    pub fn parse_bool(&mut self) -> Result<bool, Error> {
133        self.eat_bit()
134    }
135    /// Parses an unsigned integer value from the input.
136    pub fn parse_unsigned<T>(&mut self) -> Result<T, Error>
137    where
138        T: TryFrom<u8> + TryFrom<u16> + TryFrom<u32> + TryFrom<u64>,
139    {
140        let length = std::mem::size_of::<T>();
141        if self.data.len() < length {
142            return Err(Error::UnexpectedEOF);
143        }
144        match length {
145            1 => {
146                let byte = self.eat_byte()?;
147                u8::from_le_bytes([byte])
148                    .try_into()
149                    .map_err(|_| Error::ConversionError)
150            }
151            2 => {
152                let bytes = self.eat_bytes(length)?;
153                u16::from_le_bytes([bytes[0], bytes[1]])
154                    .try_into()
155                    .map_err(|_| Error::ConversionError)
156            }
157            4 => {
158                let bytes = self.eat_bytes(length)?;
159                u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
160                    .try_into()
161                    .map_err(|_| Error::ConversionError)
162            }
163            8 => {
164                let bytes = self.eat_bytes(length)?;
165                u64::from_le_bytes([
166                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
167                ])
168                .try_into()
169                .map_err(|_| Error::ConversionError)
170            }
171            _ => Err(Error::InvalidTypeSize),
172        }
173    }
174    /// Parses a signed integer value from the input.
175    pub fn parse_signed<T>(&mut self) -> Result<T, Error>
176    where
177        T: TryFrom<i8> + TryFrom<i16> + TryFrom<i32> + TryFrom<i64>,
178    {
179        let length = std::mem::size_of::<T>();
180        if self.data.len() < length {
181            return Err(Error::UnexpectedEOF);
182        }
183        match length {
184            1 => {
185                let byte = self.eat_byte()?;
186                i8::from_le_bytes([byte])
187                    .try_into()
188                    .map_err(|_| Error::ConversionError)
189            }
190            2 => {
191                let bytes = self.eat_bytes(length)?;
192                i16::from_le_bytes([bytes[0], bytes[1]])
193                    .try_into()
194                    .map_err(|_| Error::ConversionError)
195            }
196            4 => {
197                let bytes = self.eat_bytes(length)?;
198                i32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
199                    .try_into()
200                    .map_err(|_| Error::ConversionError)
201            }
202            8 => {
203                let bytes = self.eat_bytes(length)?;
204                i64::from_le_bytes([
205                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
206                ])
207                .try_into()
208                .map_err(|_| Error::ConversionError)
209            }
210            _ => Err(Error::InvalidTypeSize),
211        }
212    }
213    /// Parses a 32-bit floating point value from the input.
214    pub fn parse_f32(&mut self) -> Result<f32, Error> {
215        let bytes = self.eat_bytes(4)?;
216        Ok(f32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
217    }
218    /// Parses a 64-bit floating point value from the input.
219    pub fn parse_f64(&mut self) -> Result<f64, Error> {
220        let bytes = self.eat_bytes(8)?;
221        Ok(f64::from_le_bytes([
222            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
223        ]))
224    }
225    /// Parses a character value from the input.
226    pub fn parse_char(&mut self) -> Result<char, Error> {
227        let value = self.parse_unsigned::<u32>()?;
228        Ok(std::char::from_u32(value).unwrap())
229    }
230
231    /// Parses a string value from the input.
232    pub fn parse_str(&mut self, bytes: &mut Vec<u8>) -> Result<String, Error> {
233        'byteloop: loop {
234            let byte = self.eat_byte()?;
235            bytes.push(byte);
236            if self.peek_token(Delimiter::String)? {
237                self.eat_token(Delimiter::String)?;
238                break 'byteloop;
239            }
240        }
241        String::from_utf8(bytes.clone()).map_err(|_| Error::ConversionError)
242    }
243
244    /// Parses a byte buffer from the input.
245    pub fn parse_bytes(&mut self, bytes: &mut Vec<u8>) -> Result<(), Error> {
246        loop {
247            if self.peek_token(Delimiter::Byte)? {
248                self.eat_token(Delimiter::Byte)?;
249                break;
250            }
251            let byte = self.eat_byte()?;
252            bytes.push(byte);
253        }
254        Ok(())
255    }
256}
257
258impl<'de, 'a> Deserializer<'de> for &'a mut CustomDeserializer<'de> {
259    type Error = Error;
260
261    /// The data is not self-describing, so we need to use the type to determine how to deserialize it.
262    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
263    where
264        V: serde::de::Visitor<'de>,
265    {
266        Err(Error::UnsupportedCall("deserialize_any".to_string()))
267    }
268
269    // Primitve Types Deserialization. They are serialized as is (LE byte order).
270
271    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
272    where
273        V: serde::de::Visitor<'de>,
274    {
275        visitor.visit_bool(self.parse_bool()?)
276    }
277    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
278    where
279        V: serde::de::Visitor<'de>,
280    {
281        visitor.visit_i8(self.parse_signed::<i8>()?)
282    }
283    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
284    where
285        V: serde::de::Visitor<'de>,
286    {
287        visitor.visit_i16(self.parse_signed::<i16>()?)
288    }
289    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
290    where
291        V: serde::de::Visitor<'de>,
292    {
293        visitor.visit_i32(self.parse_signed::<i32>()?)
294    }
295    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
296    where
297        V: serde::de::Visitor<'de>,
298    {
299        visitor.visit_i64(self.parse_signed::<i64>()?)
300    }
301    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
302    where
303        V: serde::de::Visitor<'de>,
304    {
305        visitor.visit_u8(self.parse_unsigned::<u8>()?)
306    }
307    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
308    where
309        V: serde::de::Visitor<'de>,
310    {
311        visitor.visit_u16(self.parse_unsigned::<u16>()?)
312    }
313    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
314    where
315        V: serde::de::Visitor<'de>,
316    {
317        visitor.visit_u32(self.parse_unsigned::<u32>()?)
318    }
319    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
320    where
321        V: serde::de::Visitor<'de>,
322    {
323        visitor.visit_u64(self.parse_unsigned::<u64>()?)
324    }
325    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
326    where
327        V: serde::de::Visitor<'de>,
328    {
329        visitor.visit_f32(self.parse_f32()?)
330    }
331    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
332    where
333        V: serde::de::Visitor<'de>,
334    {
335        visitor.visit_f64(self.parse_f64()?)
336    }
337    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
338    where
339        V: serde::de::Visitor<'de>,
340    {
341        visitor.visit_char(self.parse_char()?)
342    }
343
344    /// String Deserialization. They are serialized as bytes + STRING_DELIMITER.
345    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
346    where
347        V: serde::de::Visitor<'de>,
348    {
349        let mut bytes = Vec::new();
350        visitor.visit_str(self.parse_str(&mut bytes)?.as_str())
351    }
352    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
353    where
354        V: serde::de::Visitor<'de>,
355    {
356        let mut bytes = Vec::new();
357        visitor.visit_string(self.parse_str(&mut bytes)?.to_string())
358    }
359
360    /// Byte Deserialization. They are serialized as bytes + BYTE_DELIMITER.
361    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
362    where
363        V: serde::de::Visitor<'de>,
364    {
365        let mut bytes = Vec::new();
366        self.parse_bytes(&mut bytes)?;
367        visitor.visit_bytes(&bytes)
368    }
369
370    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
371    where
372        V: serde::de::Visitor<'de>,
373    {
374        let mut bytes = Vec::new();
375        self.parse_bytes(&mut bytes)?;
376        visitor.visit_byte_buf(bytes)
377    }
378
379    /// Option Deserialization. They are serialized as None -> unit(), Some -> self.
380    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
381    where
382        V: serde::de::Visitor<'de>,
383    {
384        match self.peek_token(Delimiter::Unit)? {
385            true => {
386                self.eat_token(Delimiter::Unit)?;
387                visitor.visit_none()
388            }
389            false => visitor.visit_some(self),
390        }
391    }
392    /// Unit Deserialization. They are serialized as UNIT.
393    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
394    where
395        V: serde::de::Visitor<'de>,
396    {
397        match self.peek_token(Delimiter::Unit)? {
398            true => {
399                self.eat_token(Delimiter::Unit)?;
400                visitor.visit_unit()
401            }
402            _ => Err(Error::ExpectedDelimiter(Delimiter::Unit)),
403        }
404    }
405
406    /// Struct Deserialization.
407    /// - unit_struct: unit()
408    fn deserialize_unit_struct<V>(
409        self,
410        _name: &'static str,
411        visitor: V,
412    ) -> Result<V::Value, Self::Error>
413    where
414        V: serde::de::Visitor<'de>,
415    {
416        self.deserialize_unit(visitor)
417    }
418    /// - newtype_struct: self
419    fn deserialize_newtype_struct<V>(
420        self,
421        _name: &'static str,
422        visitor: V,
423    ) -> Result<V::Value, Self::Error>
424    where
425        V: serde::de::Visitor<'de>,
426    {
427        visitor.visit_newtype_struct(self)
428    }
429    /// - tuple_struct: seq()
430    fn deserialize_tuple_struct<V>(
431        self,
432        _name: &'static str,
433        _len: usize,
434        visitor: V,
435    ) -> Result<V::Value, Self::Error>
436    where
437        V: serde::de::Visitor<'de>,
438    {
439        self.deserialize_seq(visitor)
440    }
441
442    /// Enum Deserialization.
443    /// - unit_variant: ENUM_DELIMITER + variant_index
444    /// - newtype_variant: ENUM_DELIMITER + variant_index + self
445    /// - tuple_variant: ENUM_DELIMITER + variant_index + tuple()
446    /// - struct_variant: ENUM_DELIMITER + variant_index + struct()
447    fn deserialize_enum<V>(
448        self,
449        _name: &'static str,
450        _variants: &'static [&'static str],
451        visitor: V,
452    ) -> Result<V::Value, Self::Error>
453    where
454        V: serde::de::Visitor<'de>,
455    {
456        visitor.visit_enum(self)
457    }
458
459    /// Seq & Map Deserialization.
460    /// - seq: SEQ_DELIMITER + value_1 + SEQ_VALUE_DELIMITER + value_2 + SEQ_VALUE_DELIMITER + ... + SEQ_DELIMITER
461    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
462    where
463        V: serde::de::Visitor<'de>,
464    {
465        match self.peek_token(Delimiter::Seq)? {
466            true => {
467                self.eat_token(Delimiter::Seq)?;
468                let value = visitor.visit_seq(SequenceDeserializer::new(self))?;
469                if !self.peek_token(Delimiter::Seq)? {
470                    return Err(Error::ExpectedDelimiter(Delimiter::Seq));
471                }
472                self.eat_token(Delimiter::Seq)?;
473                Ok(value)
474            }
475            false => Err(Error::ExpectedDelimiter(Delimiter::Seq)),
476        }
477    }
478    /// - map: key_1 + MAP_KEY_DELIMITER + value_1 + MAP_VALUE_DELIMITER + ... + MAP_DELIMITER
479    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
480    where
481        V: serde::de::Visitor<'de>,
482    {
483        let value = visitor.visit_map(MapDeserializer::new(self))?;
484        if !self.peek_token(Delimiter::Map)? {
485            return Err(Error::ExpectedDelimiter(Delimiter::Map));
486        }
487        self.eat_token(Delimiter::Map)?;
488        Ok(value)
489    }
490
491    /// Tuple & Struct Deserialization.
492    /// - tuple: seq()
493    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
494    where
495        V: serde::de::Visitor<'de>,
496    {
497        self.deserialize_seq(visitor)
498    }
499    /// - struct: map()
500    fn deserialize_struct<V>(
501        self,
502        _name: &'static str,
503        _fields: &'static [&'static str],
504        visitor: V,
505    ) -> Result<V::Value, Self::Error>
506    where
507        V: serde::de::Visitor<'de>,
508    {
509        self.deserialize_map(visitor)
510    }
511
512    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
513    where
514        V: serde::de::Visitor<'de>,
515    {
516        self.deserialize_str(visitor)
517    }
518
519    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
520    where
521        V: serde::de::Visitor<'de>,
522    {
523        Err(Error::UnsupportedCall(
524            "deserialize_ignored_any".to_string(),
525        ))
526    }
527}
528
529/// Handles the deserialization of an enum.
530/// enum() => variant_index + (depends on variant type; handled by VARIANT_ACCESS)
531impl<'de, 'a> EnumAccess<'de> for &'a mut CustomDeserializer<'de> {
532    type Error = Error;
533    type Variant = Self;
534
535    /// Get the next variant key from the data and remove it.
536    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
537    where
538        V: serde::de::DeserializeSeed<'de>,
539    {
540        let key = self.parse_unsigned::<u32>()?;
541        Ok((seed.deserialize(key.into_deserializer())?, self))
542    }
543}
544impl<'de, 'a> VariantAccess<'de> for &'a mut CustomDeserializer<'de> {
545    type Error = Error;
546
547    /// - unit_variant: variant_index
548    fn unit_variant(self) -> Result<(), Self::Error> {
549        Ok(())
550    }
551
552    /// - newtype_variant: variant_index + self
553    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
554    where
555        T: serde::de::DeserializeSeed<'de>,
556    {
557        seed.deserialize(self)
558    }
559
560    /// - tuple_variant: variant_index + tuple() where (tuple() => seq())
561    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
562    where
563        V: serde::de::Visitor<'de>,
564    {
565        self.deserialize_seq(visitor)
566    }
567
568    /// - struct_variant: variant_index + struct() where (struct() => map())
569    fn struct_variant<V>(
570        self,
571        fields: &'static [&'static str],
572        visitor: V,
573    ) -> Result<V::Value, Self::Error>
574    where
575        V: serde::de::Visitor<'de>,
576    {
577        self.deserialize_struct("", fields, visitor)
578    }
579}
580
581/// Internal struct that handles the deserialization of a sequence.
582/// seq() => SEQ_DELIMITER + value_1 + SEQ_VALUE_DELIMITER + value_2 + SEQ_VALUE_DELIMITER + ... + SEQ_DELIMITER
583struct SequenceDeserializer<'a, 'de: 'a> {
584    deserializer: &'a mut CustomDeserializer<'de>,
585    first: bool,
586}
587impl<'a, 'de> SequenceDeserializer<'a, 'de> {
588    pub fn new(deserializer: &'a mut CustomDeserializer<'de>) -> Self {
589        Self {
590            deserializer,
591            first: true,
592        }
593    }
594}
595impl<'de, 'a> SeqAccess<'de> for SequenceDeserializer<'a, 'de> {
596    type Error = Error;
597
598    /// Grab the next element from the data and remove it.
599    /// - If at end of sequence; exit.
600    /// - If not first and not at the end of sequence; eat SEQ_VALUE_DELIMITER.
601    /// - Make not first; deserialize next element.
602    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
603    where
604        T: serde::de::DeserializeSeed<'de>,
605    {
606        // if at end of sequence; exit
607        if self.deserializer.peek_token(Delimiter::Seq)? {
608            return Ok(None);
609        }
610        // if not first and not at the end of sequence; eat SEQ_VALUE_DELIMITER
611        if !self.first {
612            if !self.deserializer.peek_token(Delimiter::SeqValue)? {
613                return Err(Error::ExpectedDelimiter(Delimiter::SeqValue));
614            }
615            self.deserializer.eat_token(Delimiter::SeqValue)?;
616        }
617        // make not first; deserialize next element
618        self.first = false;
619        seed.deserialize(&mut *self.deserializer).map(Some)
620    }
621}
622
623/// Internal struct that handles the deserialization of a map.
624/// map() => key_1 + MAP_KEY_DELIMITER + value_1 + MAP_VALUE_DELIMITER + ... + MAP_DELIMITER
625struct MapDeserializer<'a, 'de: 'a> {
626    deserializer: &'a mut CustomDeserializer<'de>,
627    first: bool,
628}
629impl<'a, 'de> MapDeserializer<'a, 'de> {
630    pub fn new(deserializer: &'a mut CustomDeserializer<'de>) -> Self {
631        Self {
632            deserializer,
633            first: true,
634        }
635    }
636}
637impl<'de, 'a> MapAccess<'de> for MapDeserializer<'a, 'de> {
638    type Error = Error;
639
640    /// Grab the next key from the data and remove it.
641    /// - If at end of map; exit.
642    /// - Make not first; deserialize next key_1.
643    /// - Deserialize next value.
644    /// - Eat MAP_KEY_DELIMITER.
645    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
646    where
647        K: serde::de::DeserializeSeed<'de>,
648    {
649        // if at end of map; exit
650        if self.deserializer.peek_token(Delimiter::Map)? {
651            return Ok(None);
652        }
653        // make not first; deserialize next key_1
654        self.first = false;
655        let value = seed.deserialize(&mut *self.deserializer).map(Some)?;
656        if !self.deserializer.peek_token(Delimiter::MapKey)? {
657            return Err(Error::ExpectedDelimiter(Delimiter::MapKey));
658        }
659        self.deserializer.eat_token(Delimiter::MapKey)?;
660        Ok(value)
661    }
662
663    /// Grab the next value from the data and remove it.
664    /// - Deserialize next value.
665    /// - Eat MAP_VALUE_DELIMITER.
666    /// - Return value.
667    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
668    where
669        V: serde::de::DeserializeSeed<'de>,
670    {
671        let value = seed.deserialize(&mut *self.deserializer)?;
672        if !self.deserializer.peek_token(Delimiter::MapValue)? {
673            return Err(Error::ExpectedDelimiter(Delimiter::MapValue));
674        }
675        self.deserializer.eat_token(Delimiter::MapValue)?;
676        Ok(value)
677    }
678}
rust_fr/deserializer.rs

rust_fr/
deserializer.rs
