musli_serde/
deserializer.rs

1use core::fmt;
2
3use musli::de::{
4    Decoder, EntriesDecoder, MapDecoder, SequenceDecoder, SizeHint, VariantDecoder, Visitor,
5};
6use musli::hint::SequenceHint;
7use musli::Context;
8use serde::de;
9
10#[cfg(feature = "alloc")]
11use alloc::string::String;
12#[cfg(feature = "alloc")]
13use alloc::vec::Vec;
14
15pub struct Deserializer<'de, 'a, D>
16where
17    D: Decoder<'de>,
18{
19    cx: &'a D::Cx,
20    decoder: D,
21}
22
23impl<'de, 'a, D> Deserializer<'de, 'a, D>
24where
25    D: Decoder<'de>,
26{
27    /// Construct a new deserializer out of a decoder.
28    pub fn new(cx: &'a D::Cx, decoder: D) -> Self {
29        Self { cx, decoder }
30    }
31}
32
33impl<'de, 'a, D> de::Deserializer<'de> for Deserializer<'de, 'a, D>
34where
35    D: Decoder<'de>,
36    <D::Cx as Context>::Error: de::Error,
37{
38    type Error = <D::Cx as Context>::Error;
39
40    #[inline]
41    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
42    where
43        V: de::Visitor<'de>,
44    {
45        self.decoder.decode_any(AnyVisitor::new(visitor))
46    }
47
48    #[inline]
49    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
50    where
51        V: de::Visitor<'de>,
52    {
53        let value = self.decoder.decode_bool()?;
54        visitor.visit_bool(value)
55    }
56
57    #[inline]
58    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
59    where
60        V: de::Visitor<'de>,
61    {
62        let value = self.decoder.decode_i8()?;
63        visitor.visit_i8(value)
64    }
65
66    #[inline]
67    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
68    where
69        V: de::Visitor<'de>,
70    {
71        let value = self.decoder.decode_i16()?;
72        visitor.visit_i16(value)
73    }
74
75    #[inline]
76    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
77    where
78        V: de::Visitor<'de>,
79    {
80        let value = self.decoder.decode_i32()?;
81        visitor.visit_i32(value)
82    }
83
84    #[inline]
85    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
86    where
87        V: de::Visitor<'de>,
88    {
89        let value = self.decoder.decode_i64()?;
90        visitor.visit_i64(value)
91    }
92
93    #[inline]
94    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
95    where
96        V: de::Visitor<'de>,
97    {
98        let value = self.decoder.decode_i128()?;
99        visitor.visit_i128(value)
100    }
101
102    #[inline]
103    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
104    where
105        V: de::Visitor<'de>,
106    {
107        let value = self.decoder.decode_u8()?;
108        visitor.visit_u8(value)
109    }
110
111    #[inline]
112    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
113    where
114        V: de::Visitor<'de>,
115    {
116        let value = self.decoder.decode_u16()?;
117        visitor.visit_u16(value)
118    }
119
120    #[inline]
121    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
122    where
123        V: de::Visitor<'de>,
124    {
125        let value = self.decoder.decode_u32()?;
126        visitor.visit_u32(value)
127    }
128
129    #[inline]
130    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
131    where
132        V: de::Visitor<'de>,
133    {
134        let value = self.decoder.decode_u64()?;
135        visitor.visit_u64(value)
136    }
137
138    #[inline]
139    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
140    where
141        V: de::Visitor<'de>,
142    {
143        let value = self.decoder.decode_u128()?;
144        visitor.visit_u128(value)
145    }
146
147    #[inline]
148    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
149    where
150        V: de::Visitor<'de>,
151    {
152        let value = self.decoder.decode_f32()?;
153        visitor.visit_f32(value)
154    }
155
156    #[inline]
157    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
158    where
159        V: de::Visitor<'de>,
160    {
161        let value = self.decoder.decode_f64()?;
162        visitor.visit_f64(value)
163    }
164
165    #[inline]
166    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
167    where
168        V: de::Visitor<'de>,
169    {
170        visitor.visit_char(self.decoder.decode_char()?)
171    }
172
173    #[inline]
174    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
175    where
176        V: de::Visitor<'de>,
177    {
178        self.decoder.decode_string(StringVisitor::new(visitor))
179    }
180
181    #[inline]
182    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
183    where
184        V: de::Visitor<'de>,
185    {
186        self.deserialize_str(visitor)
187    }
188
189    #[inline]
190    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
191    where
192        V: de::Visitor<'de>,
193    {
194        self.decoder.decode_bytes(BytesVisitor::new(visitor))
195    }
196
197    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
198    where
199        V: de::Visitor<'de>,
200    {
201        self.deserialize_bytes(visitor)
202    }
203
204    #[inline]
205    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
206    where
207        V: de::Visitor<'de>,
208    {
209        match self.decoder.decode_option()? {
210            Some(decoder) => visitor.visit_some(Deserializer::new(self.cx, decoder)),
211            None => visitor.visit_none(),
212        }
213    }
214
215    #[inline]
216    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
217    where
218        V: de::Visitor<'de>,
219    {
220        self.decoder.decode_unit()?;
221        visitor.visit_unit()
222    }
223
224    #[inline]
225    fn deserialize_unit_struct<V>(
226        self,
227        _: &'static str,
228        visitor: V,
229    ) -> Result<V::Value, Self::Error>
230    where
231        V: de::Visitor<'de>,
232    {
233        self.decoder.decode_unit()?;
234        visitor.visit_unit()
235    }
236
237    #[inline]
238    fn deserialize_newtype_struct<V>(
239        self,
240        _: &'static str,
241        visitor: V,
242    ) -> Result<V::Value, Self::Error>
243    where
244        V: de::Visitor<'de>,
245    {
246        visitor.visit_newtype_struct(Deserializer::new(self.cx, self.decoder))
247    }
248
249    #[inline]
250    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
251    where
252        V: de::Visitor<'de>,
253    {
254        self.decoder
255            .decode_sequence(|d| visitor.visit_seq(SeqAccess::new(self.cx, d)))
256    }
257
258    #[inline]
259    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
260    where
261        V: de::Visitor<'de>,
262    {
263        let hint = SequenceHint::with_size(len);
264
265        self.decoder.decode_sequence_hint(&hint, |d| {
266            visitor.visit_seq(SequenceAccess::new(self.cx, d))
267        })
268    }
269
270    #[inline]
271    fn deserialize_tuple_struct<V>(
272        self,
273        _: &'static str,
274        len: usize,
275        visitor: V,
276    ) -> Result<V::Value, Self::Error>
277    where
278        V: de::Visitor<'de>,
279    {
280        self.deserialize_tuple(len, visitor)
281    }
282
283    #[inline]
284    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
285    where
286        V: de::Visitor<'de>,
287    {
288        let mut decoder = self.decoder.decode_map_entries()?;
289        let output = visitor.visit_map(MapAccess::new(self.cx, &mut decoder))?;
290        decoder.end_entries()?;
291        Ok(output)
292    }
293
294    #[inline]
295    fn deserialize_struct<V>(
296        self,
297        _: &'static str,
298        _: &'static [&'static str],
299        visitor: V,
300    ) -> Result<V::Value, Self::Error>
301    where
302        V: de::Visitor<'de>,
303    {
304        let mut decoder = self.decoder.decode_map_entries()?;
305        let output = visitor.visit_map(StructAccess::new(self.cx, &mut decoder))?;
306        decoder.end_entries()?;
307        Ok(output)
308    }
309
310    #[inline]
311    fn deserialize_enum<V>(
312        self,
313        _: &'static str,
314        _: &'static [&'static str],
315        visitor: V,
316    ) -> Result<V::Value, Self::Error>
317    where
318        V: de::Visitor<'de>,
319    {
320        self.decoder
321            .decode_variant(|decoder| visitor.visit_enum(EnumAccess::new(self.cx, decoder)))
322    }
323
324    #[inline]
325    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
326    where
327        V: de::Visitor<'de>,
328    {
329        self.deserialize_str(visitor)
330    }
331
332    #[inline]
333    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
334    where
335        V: de::Visitor<'de>,
336    {
337        self.decoder.skip()?;
338        visitor.visit_unit()
339    }
340}
341
342struct SequenceAccess<'de, 'a, D>
343where
344    D: SequenceDecoder<'de>,
345{
346    cx: &'a D::Cx,
347    decoder: &'a mut D,
348}
349
350impl<'de, 'a, D> SequenceAccess<'de, 'a, D>
351where
352    D: SequenceDecoder<'de>,
353{
354    fn new(cx: &'a D::Cx, decoder: &'a mut D) -> Self {
355        SequenceAccess { cx, decoder }
356    }
357}
358
359impl<'de, 'a, D> de::SeqAccess<'de> for SequenceAccess<'de, 'a, D>
360where
361    D: SequenceDecoder<'de>,
362    <D::Cx as Context>::Error: de::Error,
363{
364    type Error = <D::Cx as Context>::Error;
365
366    #[inline]
367    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
368    where
369        T: de::DeserializeSeed<'de>,
370    {
371        let Some(decoder) = self.decoder.try_decode_next()? else {
372            return Ok(None);
373        };
374
375        let output = seed.deserialize(Deserializer::new(self.cx, decoder))?;
376        Ok(Some(output))
377    }
378
379    #[inline]
380    fn size_hint(&self) -> Option<usize> {
381        self.decoder.size_hint().into_option()
382    }
383}
384struct StructAccess<'de, 'a, D>
385where
386    D: EntriesDecoder<'de>,
387{
388    cx: &'a D::Cx,
389    decoder: &'a mut D,
390}
391
392impl<'de, 'a, D> StructAccess<'de, 'a, D>
393where
394    D: EntriesDecoder<'de>,
395{
396    #[inline]
397    fn new(cx: &'a D::Cx, decoder: &'a mut D) -> Self {
398        StructAccess { cx, decoder }
399    }
400}
401
402impl<'de, 'a, D> de::MapAccess<'de> for StructAccess<'de, 'a, D>
403where
404    D: EntriesDecoder<'de>,
405    <D::Cx as Context>::Error: de::Error,
406{
407    type Error = <D::Cx as Context>::Error;
408
409    #[inline]
410    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
411    where
412        K: de::DeserializeSeed<'de>,
413    {
414        let Some(decoder) = self.decoder.decode_entry_key()? else {
415            return Ok(None);
416        };
417
418        let output = seed.deserialize(Deserializer::new(self.cx, decoder))?;
419        Ok(Some(output))
420    }
421
422    #[inline]
423    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
424    where
425        V: de::DeserializeSeed<'de>,
426    {
427        let decoder = self.decoder.decode_entry_value()?;
428        let output = seed.deserialize(Deserializer::new(self.cx, decoder))?;
429        Ok(output)
430    }
431
432    #[inline]
433    fn size_hint(&self) -> Option<usize> {
434        self.decoder.size_hint().into_option()
435    }
436}
437
438struct BytesVisitor<V> {
439    visitor: V,
440}
441
442impl<V> BytesVisitor<V> {
443    #[inline]
444    fn new(visitor: V) -> Self {
445        Self { visitor }
446    }
447}
448
449impl<'de, C, V> musli::de::ValueVisitor<'de, C, [u8]> for BytesVisitor<V>
450where
451    C: ?Sized + Context,
452    C::Error: de::Error,
453    V: de::Visitor<'de>,
454{
455    type Ok = V::Value;
456
457    #[inline]
458    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
459        self.visitor.expecting(f)
460    }
461
462    #[inline]
463    #[cfg(feature = "alloc")]
464    fn visit_owned(self, _: &C, value: Vec<u8>) -> Result<Self::Ok, C::Error> {
465        de::Visitor::visit_byte_buf(self.visitor, value)
466    }
467
468    #[inline]
469    fn visit_borrowed(self, _: &C, value: &'de [u8]) -> Result<Self::Ok, C::Error> {
470        de::Visitor::visit_borrowed_bytes(self.visitor, value)
471    }
472
473    #[inline]
474    fn visit_ref(self, _: &C, value: &[u8]) -> Result<Self::Ok, C::Error> {
475        de::Visitor::visit_bytes(self.visitor, value)
476    }
477}
478
479struct SeqAccess<'de, 'a, D>
480where
481    D: SequenceDecoder<'de>,
482{
483    cx: &'a D::Cx,
484    decoder: &'a mut D,
485}
486
487impl<'de, 'a, D> SeqAccess<'de, 'a, D>
488where
489    D: SequenceDecoder<'de>,
490{
491    fn new(cx: &'a D::Cx, decoder: &'a mut D) -> Self {
492        Self { cx, decoder }
493    }
494}
495
496impl<'de, 'a, D> de::SeqAccess<'de> for SeqAccess<'de, 'a, D>
497where
498    D: SequenceDecoder<'de>,
499    <D::Cx as Context>::Error: de::Error,
500{
501    type Error = <D::Cx as Context>::Error;
502
503    #[inline]
504    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
505    where
506        T: de::DeserializeSeed<'de>,
507    {
508        let Some(decoder) = self.decoder.try_decode_next()? else {
509            return Ok(None);
510        };
511
512        let output = seed.deserialize(Deserializer::new(self.cx, decoder))?;
513        Ok(Some(output))
514    }
515
516    #[inline]
517    fn size_hint(&self) -> Option<usize> {
518        match self.decoder.size_hint() {
519            SizeHint::Exact(n) => Some(n),
520            _ => None,
521        }
522    }
523}
524
525struct MapAccess<'de, 'a, D: ?Sized>
526where
527    D: EntriesDecoder<'de>,
528{
529    cx: &'a D::Cx,
530    decoder: &'a mut D,
531}
532
533impl<'de, 'a, D: ?Sized> MapAccess<'de, 'a, D>
534where
535    D: EntriesDecoder<'de>,
536{
537    fn new(cx: &'a D::Cx, decoder: &'a mut D) -> Self {
538        Self { cx, decoder }
539    }
540}
541
542impl<'de, 'a, D: ?Sized> de::MapAccess<'de> for MapAccess<'de, 'a, D>
543where
544    D: EntriesDecoder<'de>,
545    <D::Cx as Context>::Error: de::Error,
546{
547    type Error = <D::Cx as Context>::Error;
548
549    #[inline]
550    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
551    where
552        K: de::DeserializeSeed<'de>,
553    {
554        let Some(decoder) = self.decoder.decode_entry_key()? else {
555            return Ok(None);
556        };
557
558        let output = seed.deserialize(Deserializer::new(self.cx, decoder))?;
559        Ok(Some(output))
560    }
561
562    #[inline]
563    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
564    where
565        V: de::DeserializeSeed<'de>,
566    {
567        let decoder = self.decoder.decode_entry_value()?;
568        let output = seed.deserialize(Deserializer::new(self.cx, decoder))?;
569        Ok(output)
570    }
571}
572
573struct StringVisitor<V> {
574    visitor: V,
575}
576
577impl<V> StringVisitor<V> {
578    fn new(visitor: V) -> Self {
579        Self { visitor }
580    }
581}
582
583impl<'de, C, V> musli::de::ValueVisitor<'de, C, str> for StringVisitor<V>
584where
585    C: ?Sized + Context,
586    C::Error: de::Error,
587    V: de::Visitor<'de>,
588{
589    type Ok = V::Value;
590
591    #[inline]
592    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
593        self.visitor.expecting(f)
594    }
595
596    #[inline]
597    #[cfg(feature = "alloc")]
598    fn visit_owned(self, _: &C, value: String) -> Result<Self::Ok, C::Error> {
599        de::Visitor::visit_string(self.visitor, value)
600    }
601
602    #[inline]
603    fn visit_borrowed(self, _: &C, value: &'de str) -> Result<Self::Ok, C::Error> {
604        de::Visitor::visit_borrowed_str(self.visitor, value)
605    }
606
607    #[inline]
608    fn visit_ref(self, _: &C, value: &str) -> Result<Self::Ok, C::Error> {
609        de::Visitor::visit_str(self.visitor, value)
610    }
611}
612
613struct AnyNumberVisitor<V> {
614    visitor: V,
615}
616
617impl<V> AnyNumberVisitor<V> {
618    fn new(visitor: V) -> Self {
619        Self { visitor }
620    }
621}
622
623impl<'de, C, V> musli::de::NumberVisitor<'de, C> for AnyNumberVisitor<V>
624where
625    C: ?Sized + Context,
626    C::Error: de::Error,
627    V: de::Visitor<'de>,
628{
629    type Ok = V::Value;
630
631    #[inline]
632    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
633        self.visitor.expecting(f)
634    }
635
636    #[inline]
637    fn visit_u8(self, _: &C, v: u8) -> Result<Self::Ok, C::Error> {
638        self.visitor.visit_u8(v)
639    }
640
641    #[inline]
642    fn visit_u16(self, _: &C, v: u16) -> Result<Self::Ok, C::Error> {
643        self.visitor.visit_u16(v)
644    }
645
646    #[inline]
647    fn visit_u32(self, _: &C, v: u32) -> Result<Self::Ok, C::Error> {
648        self.visitor.visit_u32(v)
649    }
650
651    #[inline]
652    fn visit_u64(self, _: &C, v: u64) -> Result<Self::Ok, C::Error> {
653        self.visitor.visit_u64(v)
654    }
655
656    #[inline]
657    fn visit_u128(self, _: &C, v: u128) -> Result<Self::Ok, C::Error> {
658        // Serde's 128-bit support is very broken, so just try to avoid it if we can.
659        // See: https://github.com/serde-rs/serde/issues/2576
660        if let Ok(v) = u64::try_from(v) {
661            return self.visitor.visit_u64(v);
662        }
663
664        self.visitor.visit_u128(v)
665    }
666
667    #[inline]
668    fn visit_i8(self, _: &C, v: i8) -> Result<Self::Ok, C::Error> {
669        self.visitor.visit_i8(v)
670    }
671
672    #[inline]
673    fn visit_i16(self, _: &C, v: i16) -> Result<Self::Ok, C::Error> {
674        self.visitor.visit_i16(v)
675    }
676
677    #[inline]
678    fn visit_i32(self, _: &C, v: i32) -> Result<Self::Ok, C::Error> {
679        self.visitor.visit_i32(v)
680    }
681
682    #[inline]
683    fn visit_i64(self, _: &C, v: i64) -> Result<Self::Ok, C::Error> {
684        self.visitor.visit_i64(v)
685    }
686
687    #[inline]
688    fn visit_i128(self, _: &C, v: i128) -> Result<Self::Ok, C::Error> {
689        // Serde's 128-bit support is very broken, so just try to avoid it if we can.
690        // See: https://github.com/serde-rs/serde/issues/2576
691        if let Ok(v) = i64::try_from(v) {
692            return self.visitor.visit_i64(v);
693        }
694
695        self.visitor.visit_i128(v)
696    }
697
698    #[inline]
699    fn visit_f32(self, _: &C, v: f32) -> Result<Self::Ok, C::Error> {
700        self.visitor.visit_f32(v)
701    }
702
703    #[inline]
704    fn visit_f64(self, _: &C, v: f64) -> Result<Self::Ok, C::Error> {
705        self.visitor.visit_f64(v)
706    }
707
708    #[inline]
709    fn visit_usize(self, cx: &C, v: usize) -> Result<Self::Ok, C::Error> {
710        if let Some(value) = unsigned_value(self.visitor, v)? {
711            return Ok(value);
712        }
713
714        Err(cx.message(format_args!("Unsupported usize value {v}")))
715    }
716
717    #[inline]
718    fn visit_isize(self, cx: &C, v: isize) -> Result<Self::Ok, C::Error> {
719        if let Some(value) = signed_value(self.visitor, v)? {
720            return Ok(value);
721        }
722
723        Err(cx.message(format_args!("Unsupported isize value {v}")))
724    }
725
726    #[inline]
727    fn visit_bytes(self, _: &C, v: &'de [u8]) -> Result<Self::Ok, C::Error> {
728        self.visitor.visit_bytes(v)
729    }
730}
731
732struct EnumAccess<'de, 'a, D>
733where
734    D: VariantDecoder<'de>,
735{
736    cx: &'a D::Cx,
737    decoder: &'a mut D,
738}
739
740impl<'de, 'a, D> EnumAccess<'de, 'a, D>
741where
742    D: VariantDecoder<'de>,
743{
744    fn new(cx: &'a D::Cx, decoder: &'a mut D) -> Self {
745        Self { cx, decoder }
746    }
747}
748
749impl<'de, 'a, D> de::VariantAccess<'de> for EnumAccess<'de, 'a, D>
750where
751    D: VariantDecoder<'de>,
752    <D::Cx as Context>::Error: de::Error,
753{
754    type Error = <D::Cx as Context>::Error;
755
756    #[inline]
757    fn unit_variant(self) -> Result<(), Self::Error> {
758        self.decoder.decode_value()?.decode_unit()
759    }
760
761    #[inline]
762    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
763    where
764        T: de::DeserializeSeed<'de>,
765    {
766        seed.deserialize(Deserializer::new(self.cx, self.decoder.decode_value()?))
767    }
768
769    #[inline]
770    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
771    where
772        V: de::Visitor<'de>,
773    {
774        let hint = SequenceHint::with_size(len);
775
776        self.decoder
777            .decode_value()?
778            .decode_sequence_hint(&hint, |tuple| {
779                visitor.visit_seq(SequenceAccess::new(self.cx, tuple))
780            })
781    }
782
783    #[inline]
784    fn struct_variant<V>(
785        self,
786        _: &'static [&'static str],
787        visitor: V,
788    ) -> Result<V::Value, Self::Error>
789    where
790        V: de::Visitor<'de>,
791    {
792        let decoder = self.decoder.decode_value()?;
793        let mut st = decoder.decode_map_entries()?;
794        let value = visitor.visit_map(StructAccess::new(self.cx, &mut st))?;
795        st.end_entries()?;
796        Ok(value)
797    }
798}
799
800impl<'de, 'a, D> de::EnumAccess<'de> for EnumAccess<'de, 'a, D>
801where
802    D: VariantDecoder<'de>,
803    <D::Cx as Context>::Error: de::Error,
804{
805    type Error = <D::Cx as Context>::Error;
806    type Variant = Self;
807
808    #[inline]
809    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
810    where
811        V: de::DeserializeSeed<'de>,
812    {
813        let tag = self.decoder.decode_tag()?;
814        let value = seed.deserialize(Deserializer::new(self.cx, tag))?;
815        Ok((value, self))
816    }
817}
818
819struct AnyVisitor<V> {
820    visitor: V,
821}
822
823impl<V> AnyVisitor<V> {
824    fn new(visitor: V) -> Self {
825        Self { visitor }
826    }
827}
828
829#[musli::visitor]
830impl<'de, C, V> Visitor<'de, C> for AnyVisitor<V>
831where
832    C: ?Sized + Context,
833    C::Error: de::Error,
834    V: de::Visitor<'de>,
835{
836    type Ok = V::Value;
837
838    type String = StringVisitor<V>;
839    type Bytes = BytesVisitor<V>;
840    type Number = AnyNumberVisitor<V>;
841
842    #[inline]
843    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
844        self.visitor.expecting(f)
845    }
846
847    #[inline]
848    fn visit_unit(self, _: &C) -> Result<Self::Ok, C::Error> {
849        self.visitor.visit_unit()
850    }
851
852    #[inline]
853    fn visit_bool(self, _: &C, v: bool) -> Result<Self::Ok, C::Error> {
854        self.visitor.visit_bool(v)
855    }
856
857    #[inline]
858    fn visit_char(self, _: &C, v: char) -> Result<Self::Ok, C::Error> {
859        self.visitor.visit_char(v)
860    }
861
862    #[inline]
863    fn visit_u8(self, _: &C, v: u8) -> Result<Self::Ok, C::Error> {
864        self.visitor.visit_u8(v)
865    }
866
867    #[inline]
868    fn visit_u16(self, _: &C, v: u16) -> Result<Self::Ok, C::Error> {
869        self.visitor.visit_u16(v)
870    }
871
872    #[inline]
873    fn visit_u32(self, _: &C, v: u32) -> Result<Self::Ok, C::Error> {
874        self.visitor.visit_u32(v)
875    }
876
877    #[inline]
878    fn visit_u64(self, _: &C, v: u64) -> Result<Self::Ok, C::Error> {
879        self.visitor.visit_u64(v)
880    }
881
882    #[inline]
883    fn visit_u128(self, _: &C, v: u128) -> Result<Self::Ok, C::Error> {
884        // Serde's 128-bit support is very broken, so just try to avoid it if we can.
885        // See: https://github.com/serde-rs/serde/issues/2576
886        if let Ok(v) = u64::try_from(v) {
887            return self.visitor.visit_u64(v);
888        }
889
890        self.visitor.visit_u128(v)
891    }
892
893    #[inline]
894    fn visit_i8(self, _: &C, v: i8) -> Result<Self::Ok, C::Error> {
895        self.visitor.visit_i8(v)
896    }
897
898    #[inline]
899    fn visit_i16(self, _: &C, v: i16) -> Result<Self::Ok, C::Error> {
900        self.visitor.visit_i16(v)
901    }
902
903    #[inline]
904    fn visit_i32(self, _: &C, v: i32) -> Result<Self::Ok, C::Error> {
905        self.visitor.visit_i32(v)
906    }
907
908    #[inline]
909    fn visit_i64(self, _: &C, v: i64) -> Result<Self::Ok, C::Error> {
910        self.visitor.visit_i64(v)
911    }
912
913    #[inline]
914    fn visit_i128(self, _: &C, v: i128) -> Result<Self::Ok, C::Error> {
915        // Serde's 128-bit support is very broken, so just try to avoid it if we can.
916        // See: https://github.com/serde-rs/serde/issues/2576
917        if let Ok(v) = i64::try_from(v) {
918            return self.visitor.visit_i64(v);
919        }
920
921        self.visitor.visit_i128(v)
922    }
923
924    #[inline]
925    fn visit_usize(self, cx: &C, v: usize) -> Result<Self::Ok, C::Error> {
926        if let Some(value) = unsigned_value(self.visitor, v)? {
927            return Ok(value);
928        }
929
930        Err(cx.message(format_args!("Unsupported usize value {v}")))
931    }
932
933    #[inline]
934    fn visit_isize(self, cx: &C, v: isize) -> Result<Self::Ok, C::Error> {
935        if let Some(value) = signed_value(self.visitor, v)? {
936            return Ok(value);
937        }
938
939        Err(cx.message(format_args!("Unsupported isize value {v}")))
940    }
941
942    #[inline]
943    fn visit_f32(self, _: &C, v: f32) -> Result<Self::Ok, C::Error> {
944        self.visitor.visit_f32(v)
945    }
946
947    #[inline]
948    fn visit_f64(self, _: &C, v: f64) -> Result<Self::Ok, C::Error> {
949        self.visitor.visit_f64(v)
950    }
951
952    #[inline]
953    fn visit_option<D>(self, cx: &C, v: Option<D>) -> Result<Self::Ok, C::Error>
954    where
955        D: Decoder<'de, Cx = C>,
956    {
957        match v {
958            Some(v) => self.visitor.visit_some(Deserializer::new(cx, v)),
959            None => self.visitor.visit_none(),
960        }
961    }
962
963    #[inline]
964    fn visit_sequence<D>(self, cx: &C, decoder: &mut D) -> Result<Self::Ok, C::Error>
965    where
966        D: SequenceDecoder<'de, Cx = C>,
967    {
968        self.visitor.visit_seq(SeqAccess::new(cx, decoder))
969    }
970
971    #[inline]
972    fn visit_map<D>(self, cx: &C, decoder: &mut D) -> Result<Self::Ok, C::Error>
973    where
974        D: MapDecoder<'de, Cx = C>,
975    {
976        let mut map_decoder = decoder.decode_remaining_entries()?;
977        let value = self
978            .visitor
979            .visit_map(MapAccess::new(cx, &mut map_decoder))?;
980        map_decoder.end_entries()?;
981        Ok(value)
982    }
983
984    #[inline]
985    fn visit_string(self, _: &C, _: SizeHint) -> Result<Self::String, C::Error> {
986        Ok(StringVisitor::new(self.visitor))
987    }
988
989    #[inline]
990    fn visit_bytes(self, _: &C, _: SizeHint) -> Result<Self::Bytes, C::Error> {
991        Ok(BytesVisitor::new(self.visitor))
992    }
993
994    #[inline]
995    fn visit_number(self, _: &C) -> Result<Self::Number, C::Error> {
996        Ok(AnyNumberVisitor::new(self.visitor))
997    }
998}
999
1000fn unsigned_value<'de, V, E>(visitor: V, v: usize) -> Result<Option<V::Value>, E>
1001where
1002    V: de::Visitor<'de>,
1003    E: de::Error,
1004{
1005    if let Ok(v) = u32::try_from(v) {
1006        return Ok(Some(visitor.visit_u32(v)?));
1007    }
1008
1009    if let Ok(v) = u64::try_from(v) {
1010        return Ok(Some(visitor.visit_u64(v)?));
1011    }
1012
1013    if let Ok(v) = u128::try_from(v) {
1014        return Ok(Some(visitor.visit_u128(v)?));
1015    }
1016
1017    Ok(None)
1018}
1019
1020fn signed_value<'de, V, E>(visitor: V, v: isize) -> Result<Option<V::Value>, E>
1021where
1022    V: de::Visitor<'de>,
1023    E: de::Error,
1024{
1025    if let Ok(v) = i32::try_from(v) {
1026        return Ok(Some(visitor.visit_i32(v)?));
1027    }
1028
1029    if let Ok(v) = i64::try_from(v) {
1030        return Ok(Some(visitor.visit_i64(v)?));
1031    }
1032
1033    if let Ok(v) = i128::try_from(v) {
1034        return Ok(Some(visitor.visit_i128(v)?));
1035    }
1036
1037    Ok(None)
1038}
musli_serde/deserializer.rs

musli_serde/
deserializer.rs
