bcs/
de.rs

1// Copyright (c) The Diem Core Contributors
2// SPDX-License-Identifier: Apache-2.0
3
4use crate::error::{Error, Result};
5use serde::de::{self, Deserialize, DeserializeOwned, DeserializeSeed, IntoDeserializer, Visitor};
6use std::{convert::TryFrom, io::Read};
7
8/// Deserializes a `&[u8]` into a type.
9///
10/// This function will attempt to interpret `bytes` as the BCS serialized form of `T` and
11/// deserialize `T` from `bytes`.
12///
13/// # Examples
14///
15/// ```
16/// use bcs::from_bytes;
17/// use serde::Deserialize;
18///
19/// #[derive(Deserialize)]
20/// struct Ip([u8; 4]);
21///
22/// #[derive(Deserialize)]
23/// struct Port(u16);
24///
25/// #[derive(Deserialize)]
26/// struct SocketAddr {
27///     ip: Ip,
28///     port: Port,
29/// }
30///
31/// let bytes = vec![0x7f, 0x00, 0x00, 0x01, 0x41, 0x1f];
32/// let socket_addr: SocketAddr = from_bytes(&bytes).unwrap();
33///
34/// assert_eq!(socket_addr.ip.0, [127, 0, 0, 1]);
35/// assert_eq!(socket_addr.port.0, 8001);
36/// ```
37pub fn from_bytes<'a, T>(bytes: &'a [u8]) -> Result<T>
38where
39    T: Deserialize<'a>,
40{
41    let mut deserializer = Deserializer::new(bytes, crate::MAX_CONTAINER_DEPTH);
42    let t = T::deserialize(&mut deserializer)?;
43    deserializer.end()?;
44    Ok(t)
45}
46
47/// Same as `from_bytes` but use `limit` as max container depth instead of MAX_CONTAINER_DEPTH`
48/// Note that `limit` has to be lower than MAX_CONTAINER_DEPTH
49pub fn from_bytes_with_limit<'a, T>(bytes: &'a [u8], limit: usize) -> Result<T>
50where
51    T: Deserialize<'a>,
52{
53    if limit > crate::MAX_CONTAINER_DEPTH {
54        return Err(Error::NotSupported("limit exceeds the max allowed depth"));
55    }
56    let mut deserializer = Deserializer::new(bytes, limit);
57    let t = T::deserialize(&mut deserializer)?;
58    deserializer.end()?;
59    Ok(t)
60}
61
62/// Perform a stateful deserialization from a `&[u8]` using the provided `seed`.
63pub fn from_bytes_seed<'a, T>(seed: T, bytes: &'a [u8]) -> Result<T::Value>
64where
65    T: DeserializeSeed<'a>,
66{
67    let mut deserializer = Deserializer::new(bytes, crate::MAX_CONTAINER_DEPTH);
68    let t = seed.deserialize(&mut deserializer)?;
69    deserializer.end()?;
70    Ok(t)
71}
72
73/// Same as `from_bytes_seed` but use `limit` as max container depth instead of MAX_CONTAINER_DEPTH`
74/// Note that `limit` has to be lower than MAX_CONTAINER_DEPTH
75pub fn from_bytes_seed_with_limit<'a, T>(seed: T, bytes: &'a [u8], limit: usize) -> Result<T::Value>
76where
77    T: DeserializeSeed<'a>,
78{
79    if limit > crate::MAX_CONTAINER_DEPTH {
80        return Err(Error::NotSupported("limit exceeds the max allowed depth"));
81    }
82    let mut deserializer = Deserializer::new(bytes, limit);
83    let t = seed.deserialize(&mut deserializer)?;
84    deserializer.end()?;
85    Ok(t)
86}
87
88/// Deserialize a type from an implementation of [`Read`].
89pub fn from_reader<T>(mut reader: impl Read) -> Result<T>
90where
91    T: DeserializeOwned,
92{
93    let mut deserializer = Deserializer::from_reader(&mut reader, crate::MAX_CONTAINER_DEPTH);
94    let t = T::deserialize(&mut deserializer)?;
95    deserializer.end()?;
96    Ok(t)
97}
98
99/// Same as `from_reader_seed` but use `limit` as max container depth instead of MAX_CONTAINER_DEPTH`
100/// Note that `limit` has to be lower than MAX_CONTAINER_DEPTH
101pub fn from_reader_with_limit<T>(mut reader: impl Read, limit: usize) -> Result<T>
102where
103    T: DeserializeOwned,
104{
105    if limit > crate::MAX_CONTAINER_DEPTH {
106        return Err(Error::NotSupported("limit exceeds the max allowed depth"));
107    }
108    let mut deserializer = Deserializer::from_reader(&mut reader, limit);
109    let t = T::deserialize(&mut deserializer)?;
110    deserializer.end()?;
111    Ok(t)
112}
113
114/// Deserialize a type from an implementation of [`Read`] using the provided seed
115pub fn from_reader_seed<T, V>(seed: T, mut reader: impl Read) -> Result<V>
116where
117    for<'a> T: DeserializeSeed<'a, Value = V>,
118{
119    let mut deserializer = Deserializer::from_reader(&mut reader, crate::MAX_CONTAINER_DEPTH);
120    let t = seed.deserialize(&mut deserializer)?;
121    deserializer.end()?;
122    Ok(t)
123}
124
125/// Same as `from_reader_seed` but use `limit` as max container depth instead of MAX_CONTAINER_DEPTH`
126/// Note that `limit` has to be lower than MAX_CONTAINER_DEPTH
127pub fn from_reader_seed_with_limit<T, V>(seed: T, mut reader: impl Read, limit: usize) -> Result<V>
128where
129    for<'a> T: DeserializeSeed<'a, Value = V>,
130{
131    if limit > crate::MAX_CONTAINER_DEPTH {
132        return Err(Error::NotSupported("limit exceeds the max allowed depth"));
133    }
134    let mut deserializer = Deserializer::from_reader(&mut reader, limit);
135    let t = seed.deserialize(&mut deserializer)?;
136    deserializer.end()?;
137    Ok(t)
138}
139
140/// Deserialization implementation for BCS
141struct Deserializer<R> {
142    input: R,
143    max_remaining_depth: usize,
144}
145
146impl<'de, R: Read> Deserializer<TeeReader<'de, R>> {
147    fn from_reader(input: &'de mut R, max_remaining_depth: usize) -> Self {
148        Deserializer {
149            input: TeeReader::new(input),
150            max_remaining_depth,
151        }
152    }
153}
154
155impl<'de> Deserializer<&'de [u8]> {
156    /// Creates a new `Deserializer` which will be deserializing the provided
157    /// input.
158    fn new(input: &'de [u8], max_remaining_depth: usize) -> Self {
159        Deserializer {
160            input,
161            max_remaining_depth,
162        }
163    }
164}
165
166/// A reader that can optionally capture all bytes from an underlying [`Read`]er
167struct TeeReader<'de, R> {
168    /// the underlying reader
169    reader: &'de mut R,
170    /// If non-empty, all bytes read from the underlying reader will be captured in the last entry here.
171    captured_keys: Vec<Vec<u8>>,
172}
173
174impl<'de, R> TeeReader<'de, R> {
175    /// Wraps the provided reader in a new [`TeeReader`].
176    pub fn new(reader: &'de mut R) -> Self {
177        Self {
178            reader,
179            captured_keys: Vec::new(),
180        }
181    }
182}
183
184impl<'de, R: Read> Read for TeeReader<'de, R> {
185    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
186        let bytes_read = self.reader.read(buf)?;
187        if let Some(buffer) = self.captured_keys.last_mut() {
188            buffer.extend_from_slice(&buf[..bytes_read]);
189        }
190        Ok(bytes_read)
191    }
192}
193
194trait BcsDeserializer<'de> {
195    type MaybeBorrowedBytes: AsRef<[u8]>;
196
197    fn fill_slice(&mut self, slice: &mut [u8]) -> Result<()>;
198
199    fn parse_and_visit_str<V>(&mut self, visitor: V) -> Result<V::Value>
200    where
201        V: Visitor<'de>;
202
203    fn parse_and_visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value>
204    where
205        V: Visitor<'de>;
206
207    fn next_key_seed<V: DeserializeSeed<'de>>(
208        &mut self,
209        seed: V,
210    ) -> Result<(V::Value, Self::MaybeBorrowedBytes), Error>;
211
212    /// The `Deserializer::end` method should be called after a type has been
213    /// fully deserialized. This allows the `Deserializer` to validate that
214    /// the there are no more bytes remaining in the input stream.
215    fn end(&mut self) -> Result<()>;
216
217    fn parse_bool(&mut self) -> Result<bool> {
218        let byte = self.next()?;
219
220        match byte {
221            0 => Ok(false),
222            1 => Ok(true),
223            _ => Err(Error::ExpectedBoolean),
224        }
225    }
226
227    fn next(&mut self) -> Result<u8> {
228        let mut byte = [0u8; 1];
229        self.fill_slice(&mut byte)?;
230        Ok(byte[0])
231    }
232
233    fn parse_u8(&mut self) -> Result<u8> {
234        self.next()
235    }
236
237    fn parse_u16(&mut self) -> Result<u16> {
238        let mut le_bytes = [0; 2];
239        self.fill_slice(&mut le_bytes)?;
240        Ok(u16::from_le_bytes(le_bytes))
241    }
242
243    fn parse_u32(&mut self) -> Result<u32> {
244        let mut le_bytes = [0; 4];
245        self.fill_slice(&mut le_bytes)?;
246        Ok(u32::from_le_bytes(le_bytes))
247    }
248
249    fn parse_u64(&mut self) -> Result<u64> {
250        let mut le_bytes = [0; 8];
251        self.fill_slice(&mut le_bytes)?;
252        Ok(u64::from_le_bytes(le_bytes))
253    }
254
255    fn parse_u128(&mut self) -> Result<u128> {
256        let mut le_bytes = [0; 16];
257        self.fill_slice(&mut le_bytes)?;
258        Ok(u128::from_le_bytes(le_bytes))
259    }
260
261    fn parse_u32_from_uleb128(&mut self) -> Result<u32> {
262        let mut value: u64 = 0;
263        for shift in (0..32).step_by(7) {
264            let byte = self.next()?;
265            let digit = byte & 0x7f;
266            value |= u64::from(digit) << shift;
267            // If the highest bit of `byte` is 0, return the final value.
268            if digit == byte {
269                if shift > 0 && digit == 0 {
270                    // We only accept canonical ULEB128 encodings, therefore the
271                    // heaviest (and last) base-128 digit must be non-zero.
272                    return Err(Error::NonCanonicalUleb128Encoding);
273                }
274                // Decoded integer must not overflow.
275                return u32::try_from(value)
276                    .map_err(|_| Error::IntegerOverflowDuringUleb128Decoding);
277            }
278        }
279        // Decoded integer must not overflow.
280        Err(Error::IntegerOverflowDuringUleb128Decoding)
281    }
282
283    fn parse_length(&mut self) -> Result<usize> {
284        let len = self.parse_u32_from_uleb128()? as usize;
285        if len > crate::MAX_SEQUENCE_LENGTH {
286            return Err(Error::ExceededMaxLen(len));
287        }
288        Ok(len)
289    }
290}
291
292impl<'de, R: Read> Deserializer<TeeReader<'de, R>> {
293    fn parse_vec(&mut self) -> Result<Vec<u8>> {
294        let len = self.parse_length()?;
295        let mut output = vec![0; len];
296        self.fill_slice(&mut output)?;
297        Ok(output)
298    }
299
300    fn parse_string(&mut self) -> Result<String> {
301        let vec = self.parse_vec()?;
302        String::from_utf8(vec).map_err(|_| Error::Utf8)
303    }
304}
305
306impl<'de, R: Read> BcsDeserializer<'de> for Deserializer<TeeReader<'de, R>> {
307    type MaybeBorrowedBytes = Vec<u8>;
308
309    fn fill_slice(&mut self, slice: &mut [u8]) -> Result<()> {
310        Ok(self.input.read_exact(slice)?)
311    }
312
313    fn parse_and_visit_str<V>(&mut self, visitor: V) -> Result<V::Value>
314    where
315        V: Visitor<'de>,
316    {
317        visitor.visit_string(self.parse_string()?)
318    }
319
320    fn parse_and_visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value>
321    where
322        V: Visitor<'de>,
323    {
324        visitor.visit_byte_buf(self.parse_vec()?)
325    }
326
327    fn next_key_seed<V: DeserializeSeed<'de>>(
328        &mut self,
329        seed: V,
330    ) -> Result<(V::Value, Self::MaybeBorrowedBytes), Error> {
331        self.input.captured_keys.push(Vec::new());
332        let key_value = seed.deserialize(&mut *self)?;
333        let key_bytes = self.input.captured_keys.pop().unwrap();
334        if let Some(previous_key) = self.input.captured_keys.last_mut() {
335            previous_key.extend_from_slice(&key_bytes);
336        }
337        Ok((key_value, key_bytes))
338    }
339
340    fn end(&mut self) -> Result<()> {
341        let mut byte = [0u8; 1];
342        match self.input.read_exact(&mut byte) {
343            Ok(_) => Err(Error::RemainingInput),
344            Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
345            Err(e) => Err(e.into()),
346        }
347    }
348}
349
350impl<'de> BcsDeserializer<'de> for Deserializer<&'de [u8]> {
351    type MaybeBorrowedBytes = &'de [u8];
352    fn next(&mut self) -> Result<u8> {
353        let byte = self.peek()?;
354        self.input = &self.input[1..];
355        Ok(byte)
356    }
357
358    fn fill_slice(&mut self, slice: &mut [u8]) -> Result<()> {
359        for byte in slice {
360            *byte = self.next()?;
361        }
362        Ok(())
363    }
364
365    fn parse_and_visit_str<V>(&mut self, visitor: V) -> Result<V::Value>
366    where
367        V: Visitor<'de>,
368    {
369        visitor.visit_borrowed_str(self.parse_string()?)
370    }
371
372    fn parse_and_visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value>
373    where
374        V: Visitor<'de>,
375    {
376        visitor.visit_borrowed_bytes(self.parse_bytes()?)
377    }
378
379    fn next_key_seed<V: DeserializeSeed<'de>>(
380        &mut self,
381        seed: V,
382    ) -> Result<(V::Value, Self::MaybeBorrowedBytes), Error> {
383        let previous_input_slice = self.input;
384        let key_value = seed.deserialize(&mut *self)?;
385        let key_len = previous_input_slice.len().saturating_sub(self.input.len());
386        let key_bytes = &previous_input_slice[..key_len];
387        Ok((key_value, key_bytes))
388    }
389
390    fn end(&mut self) -> Result<()> {
391        if self.input.is_empty() {
392            Ok(())
393        } else {
394            Err(Error::RemainingInput)
395        }
396    }
397}
398
399impl<'de> Deserializer<&'de [u8]> {
400    fn peek(&mut self) -> Result<u8> {
401        self.input.first().copied().ok_or(Error::Eof)
402    }
403
404    fn parse_bytes(&mut self) -> Result<&'de [u8]> {
405        let len = self.parse_length()?;
406        let slice = self.input.get(..len).ok_or(Error::Eof)?;
407        self.input = &self.input[len..];
408        Ok(slice)
409    }
410
411    fn parse_string(&mut self) -> Result<&'de str> {
412        let slice = self.parse_bytes()?;
413        std::str::from_utf8(slice).map_err(|_| Error::Utf8)
414    }
415}
416
417impl<R> Deserializer<R> {
418    fn enter_named_container(&mut self, name: &'static str) -> Result<()> {
419        if self.max_remaining_depth == 0 {
420            return Err(Error::ExceededContainerDepthLimit(name));
421        }
422        self.max_remaining_depth -= 1;
423        Ok(())
424    }
425
426    fn leave_named_container(&mut self) {
427        self.max_remaining_depth += 1;
428    }
429}
430
431impl<'de, 'a, R> de::Deserializer<'de> for &'a mut Deserializer<R>
432where
433    Deserializer<R>: BcsDeserializer<'de>,
434{
435    type Error = Error;
436
437    // BCS is not a self-describing format so we can't implement `deserialize_any`
438    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
439    where
440        V: Visitor<'de>,
441    {
442        Err(Error::NotSupported("deserialize_any"))
443    }
444
445    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
446    where
447        V: Visitor<'de>,
448    {
449        visitor.visit_bool(self.parse_bool()?)
450    }
451
452    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
453    where
454        V: Visitor<'de>,
455    {
456        visitor.visit_i8(self.parse_u8()? as i8)
457    }
458
459    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
460    where
461        V: Visitor<'de>,
462    {
463        visitor.visit_i16(self.parse_u16()? as i16)
464    }
465
466    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
467    where
468        V: Visitor<'de>,
469    {
470        visitor.visit_i32(self.parse_u32()? as i32)
471    }
472
473    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
474    where
475        V: Visitor<'de>,
476    {
477        visitor.visit_i64(self.parse_u64()? as i64)
478    }
479
480    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
481    where
482        V: Visitor<'de>,
483    {
484        visitor.visit_i128(self.parse_u128()? as i128)
485    }
486
487    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
488    where
489        V: Visitor<'de>,
490    {
491        visitor.visit_u8(self.parse_u8()?)
492    }
493
494    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
495    where
496        V: Visitor<'de>,
497    {
498        visitor.visit_u16(self.parse_u16()?)
499    }
500
501    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
502    where
503        V: Visitor<'de>,
504    {
505        visitor.visit_u32(self.parse_u32()?)
506    }
507
508    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
509    where
510        V: Visitor<'de>,
511    {
512        visitor.visit_u64(self.parse_u64()?)
513    }
514
515    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
516    where
517        V: Visitor<'de>,
518    {
519        visitor.visit_u128(self.parse_u128()?)
520    }
521
522    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
523    where
524        V: Visitor<'de>,
525    {
526        Err(Error::NotSupported("deserialize_f32"))
527    }
528
529    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
530    where
531        V: Visitor<'de>,
532    {
533        Err(Error::NotSupported("deserialize_f64"))
534    }
535
536    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
537    where
538        V: Visitor<'de>,
539    {
540        Err(Error::NotSupported("deserialize_char"))
541    }
542
543    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
544    where
545        V: Visitor<'de>,
546    {
547        self.parse_and_visit_str(visitor)
548    }
549
550    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
551    where
552        V: Visitor<'de>,
553    {
554        self.parse_and_visit_str(visitor)
555    }
556
557    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
558    where
559        V: Visitor<'de>,
560    {
561        self.parse_and_visit_bytes(visitor)
562    }
563
564    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
565    where
566        V: Visitor<'de>,
567    {
568        self.parse_and_visit_bytes(visitor)
569    }
570
571    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
572    where
573        V: Visitor<'de>,
574    {
575        let byte = self.next()?;
576
577        match byte {
578            0 => visitor.visit_none(),
579            1 => visitor.visit_some(self),
580            _ => Err(Error::ExpectedOption),
581        }
582    }
583
584    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
585    where
586        V: Visitor<'de>,
587    {
588        visitor.visit_unit()
589    }
590
591    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
592    where
593        V: Visitor<'de>,
594    {
595        self.enter_named_container(name)?;
596        let r = self.deserialize_unit(visitor);
597        self.leave_named_container();
598        r
599    }
600
601    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
602    where
603        V: Visitor<'de>,
604    {
605        self.enter_named_container(name)?;
606        let r = visitor.visit_newtype_struct(&mut *self);
607        self.leave_named_container();
608        r
609    }
610
611    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
612    where
613        V: Visitor<'de>,
614    {
615        let len = self.parse_length()?;
616        visitor.visit_seq(SeqDeserializer::new(self, len))
617    }
618
619    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
620    where
621        V: Visitor<'de>,
622    {
623        visitor.visit_seq(SeqDeserializer::new(self, len))
624    }
625
626    fn deserialize_tuple_struct<V>(
627        self,
628        name: &'static str,
629        len: usize,
630        visitor: V,
631    ) -> Result<V::Value>
632    where
633        V: Visitor<'de>,
634    {
635        self.enter_named_container(name)?;
636        let r = visitor.visit_seq(SeqDeserializer::new(self, len));
637        self.leave_named_container();
638        r
639    }
640
641    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
642    where
643        V: Visitor<'de>,
644    {
645        let len = self.parse_length()?;
646        visitor.visit_map(MapDeserializer::new(self, len))
647    }
648
649    fn deserialize_struct<V>(
650        self,
651        name: &'static str,
652        fields: &'static [&'static str],
653        visitor: V,
654    ) -> Result<V::Value>
655    where
656        V: Visitor<'de>,
657    {
658        self.enter_named_container(name)?;
659        let r = visitor.visit_seq(SeqDeserializer::new(self, fields.len()));
660        self.leave_named_container();
661        r
662    }
663
664    fn deserialize_enum<V>(
665        self,
666        name: &'static str,
667        _variants: &'static [&'static str],
668        visitor: V,
669    ) -> Result<V::Value>
670    where
671        V: Visitor<'de>,
672    {
673        self.enter_named_container(name)?;
674        let r = visitor.visit_enum(&mut *self);
675        self.leave_named_container();
676        r
677    }
678
679    // BCS does not utilize identifiers, so throw them away
680    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
681    where
682        V: Visitor<'de>,
683    {
684        self.deserialize_bytes(_visitor)
685    }
686
687    // BCS is not a self-describing format so we can't implement `deserialize_ignored_any`
688    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
689    where
690        V: Visitor<'de>,
691    {
692        Err(Error::NotSupported("deserialize_ignored_any"))
693    }
694
695    // BCS is not a human readable format
696    fn is_human_readable(&self) -> bool {
697        false
698    }
699}
700
701struct SeqDeserializer<'a, R> {
702    de: &'a mut Deserializer<R>,
703    remaining: usize,
704}
705#[allow(clippy::needless_borrow)]
706impl<'a, R> SeqDeserializer<'a, R> {
707    fn new(de: &'a mut Deserializer<R>, remaining: usize) -> Self {
708        Self { de, remaining }
709    }
710}
711
712impl<'a, 'de, R> de::SeqAccess<'de> for SeqDeserializer<'a, R>
713where
714    Deserializer<R>: BcsDeserializer<'de>,
715{
716    type Error = Error;
717
718    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
719    where
720        T: DeserializeSeed<'de>,
721    {
722        if self.remaining == 0 {
723            Ok(None)
724        } else {
725            self.remaining -= 1;
726            seed.deserialize(&mut *self.de).map(Some)
727        }
728    }
729
730    fn size_hint(&self) -> Option<usize> {
731        Some(self.remaining)
732    }
733}
734
735struct MapDeserializer<'a, R, B> {
736    de: &'a mut Deserializer<R>,
737    remaining: usize,
738    previous_key_bytes: Option<B>,
739}
740
741impl<'a, R, B> MapDeserializer<'a, R, B> {
742    fn new(de: &'a mut Deserializer<R>, remaining: usize) -> Self {
743        Self {
744            de,
745            remaining,
746            previous_key_bytes: None,
747        }
748    }
749}
750
751impl<'de, 'a, R, B: AsRef<[u8]>> de::MapAccess<'de> for MapDeserializer<'a, R, B>
752where
753    Deserializer<R>: BcsDeserializer<'de, MaybeBorrowedBytes = B>,
754{
755    type Error = Error;
756
757    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
758    where
759        K: DeserializeSeed<'de>,
760    {
761        match self.remaining.checked_sub(1) {
762            None => Ok(None),
763            Some(remaining) => {
764                let (key_value, key_bytes) = self.de.next_key_seed(seed)?;
765                if let Some(previous_key_bytes) = &self.previous_key_bytes {
766                    if previous_key_bytes.as_ref() >= key_bytes.as_ref() {
767                        return Err(Error::NonCanonicalMap);
768                    }
769                }
770                self.remaining = remaining;
771                self.previous_key_bytes = Some(key_bytes);
772                Ok(Some(key_value))
773            }
774        }
775    }
776
777    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
778    where
779        V: DeserializeSeed<'de>,
780    {
781        seed.deserialize(&mut *self.de)
782    }
783
784    fn size_hint(&self) -> Option<usize> {
785        Some(self.remaining)
786    }
787}
788
789impl<'de, 'a, R> de::EnumAccess<'de> for &'a mut Deserializer<R>
790where
791    Deserializer<R>: BcsDeserializer<'de>,
792{
793    type Error = Error;
794    type Variant = Self;
795
796    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
797    where
798        V: DeserializeSeed<'de>,
799    {
800        let variant_index = self.parse_u32_from_uleb128()?;
801        let result: Result<V::Value> = seed.deserialize(variant_index.into_deserializer());
802        Ok((result?, self))
803    }
804}
805
806impl<'de, 'a, R> de::VariantAccess<'de> for &'a mut Deserializer<R>
807where
808    Deserializer<R>: BcsDeserializer<'de>,
809{
810    type Error = Error;
811
812    fn unit_variant(self) -> Result<()> {
813        Ok(())
814    }
815
816    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
817    where
818        T: DeserializeSeed<'de>,
819    {
820        seed.deserialize(self)
821    }
822
823    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
824    where
825        V: Visitor<'de>,
826    {
827        de::Deserializer::deserialize_tuple(self, len, visitor)
828    }
829
830    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
831    where
832        V: Visitor<'de>,
833    {
834        de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
835    }
836}
bcs/de.rs

bcs/
de.rs
