msgpackin/
de.rs

1//! `feature=serde` serde Deserializer implementations
2
3use crate::producer::*;
4use crate::*;
5use serde::de;
6use serde::Deserialize;
7
8/// Deserialize from something that can be converted
9/// into a DynProducerComplete, such as a byte array slice (`&[u8]`)
10pub fn from_ref<'de, P, T>(p: P) -> Result<T>
11where
12    P: Into<DynProducerComplete<'de>>,
13    T: Deserialize<'de>,
14{
15    from_ref_config(p, &Config::default())
16}
17
18/// Deserialize from something that can be converted
19/// into a DynProducerComplete, such as a byte array slice (`&[u8]`)
20pub fn from_ref_config<'de, P, T>(p: P, config: &Config) -> Result<T>
21where
22    P: Into<DynProducerComplete<'de>>,
23    T: Deserialize<'de>,
24{
25    let mut deserializer = DeserializerSync::from_ref_config(p, config)?;
26    T::deserialize(&mut deserializer)
27}
28
29/// Deserialize from something that can be converted
30/// into a DynProducerSync, such as a byte array slice (`&[u8]`)
31pub fn from_sync<'de, P, T>(p: P) -> Result<T>
32where
33    P: Into<DynProducerSync<'de>>,
34    T: de::DeserializeOwned,
35{
36    from_sync_config(p, &Config::default())
37}
38
39/// Deserialize from something that can be converted
40/// into a DynProducerSync, such as a byte array slice (`&[u8]`)
41pub fn from_sync_config<'de, P, T>(p: P, config: &Config) -> Result<T>
42where
43    P: Into<DynProducerSync<'de>>,
44    T: de::DeserializeOwned,
45{
46    let mut deserializer = DeserializerSync::from_sync_config(p, config)?;
47    T::deserialize(&mut deserializer)
48}
49
50/// Deserialize from something that can be converted
51/// into a DynProducerAsync, such as a byte array slice (`&[u8]`)
52pub async fn from_async<'de, P, T>(p: P) -> Result<T>
53where
54    P: Into<DynProducerAsync<'de>>,
55    T: de::DeserializeOwned,
56{
57    from_async_config(p, &Config::default()).await
58}
59
60/// Deserialize from something that can be converted
61/// into a DynProducerAsync, such as a byte array slice (`&[u8]`)
62pub async fn from_async_config<'de, P, T>(p: P, config: &Config) -> Result<T>
63where
64    P: Into<DynProducerAsync<'de>>,
65    T: de::DeserializeOwned,
66{
67    let mut deserializer =
68        DeserializerSync::from_async_config(p, config).await?;
69    T::deserialize(&mut deserializer)
70}
71
72/// a value that is either owned or a reference
73enum MetaValue<'lt> {
74    O(Value),
75    R(ValueRef<'lt>),
76}
77
78impl<'lt> fmt::Debug for MetaValue<'lt> {
79    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
80        match self {
81            MetaValue::O(Value::Nil) | MetaValue::R(ValueRef::Nil) => {
82                f.write_str("nil")
83            }
84            MetaValue::O(Value::Bool(b)) | MetaValue::R(ValueRef::Bool(b)) => {
85                write!(f, "bool({})", b)
86            }
87            MetaValue::O(Value::Num(n)) | MetaValue::R(ValueRef::Num(n)) => {
88                write!(f, "num({})", n)
89            }
90            MetaValue::O(Value::Bin(_)) | MetaValue::R(ValueRef::Bin(_)) => {
91                f.write_str("bin")
92            }
93            MetaValue::O(Value::Str(_)) | MetaValue::R(ValueRef::Str(_)) => {
94                f.write_str("str")
95            }
96            MetaValue::O(Value::Ext(t, _))
97            | MetaValue::R(ValueRef::Ext(t, _)) => {
98                write!(f, "ext({})", t)
99            }
100            MetaValue::O(Value::Arr(_)) | MetaValue::R(ValueRef::Arr(_)) => {
101                f.write_str("seq")
102            }
103            MetaValue::O(Value::Map(_)) | MetaValue::R(ValueRef::Map(_)) => {
104                f.write_str("map")
105            }
106        }
107    }
108}
109
110/// Msgpackin serde DeserializerSync
111pub struct DeserializerSync<'de>(Option<MetaValue<'de>>);
112
113impl<'de> DeserializerSync<'de> {
114    /// Construct a DeserializerSync from something that can be converted
115    /// into a DynProducerComplete, such as a byte array slice (`&[u8]`)
116    pub fn from_ref_config<P: Into<DynProducerComplete<'de>>>(
117        p: P,
118        config: &Config,
119    ) -> Result<DeserializerSync<'de>> {
120        Ok(Self(Some(MetaValue::R(ValueRef::from_ref_config(
121            p, config,
122        )?))))
123    }
124
125    /// Construct a DeserializerSync from something that can be converted
126    /// into a DynProducerSync, such as a byte array slice (`&[u8]`)
127    pub fn from_sync_config<'a, P: Into<DynProducerSync<'a>>>(
128        p: P,
129        config: &Config,
130    ) -> Result<DeserializerSync<'de>> {
131        Ok(Self(Some(MetaValue::O(Value::from_sync_config(
132            p, config,
133        )?))))
134    }
135
136    /// Construct a DeserializerSync from something that can be converted
137    /// into a DynProducerAsync, such as a byte array slice (`&[u8]`)
138    pub async fn from_async_config<'a, P: Into<DynProducerAsync<'a>>>(
139        p: P,
140        config: &Config,
141    ) -> Result<DeserializerSync<'de>> {
142        Ok(Self(Some(MetaValue::O(
143            Value::from_async_config(p, config).await?,
144        ))))
145    }
146}
147
148impl<'de, 'a> de::Deserializer<'de> for &'a mut DeserializerSync<'de> {
149    type Error = Error;
150
151    fn is_human_readable(&self) -> bool {
152        false
153    }
154
155    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
156    where
157        V: de::Visitor<'de>,
158    {
159        match &self.0 {
160            Some(MetaValue::O(Value::Nil))
161            | Some(MetaValue::R(ValueRef::Nil)) => {
162                self.deserialize_unit(visitor)
163            }
164            Some(MetaValue::O(Value::Bool(_)))
165            | Some(MetaValue::R(ValueRef::Bool(_))) => {
166                self.deserialize_bool(visitor)
167            }
168            Some(MetaValue::O(Value::Num(n)))
169            | Some(MetaValue::R(ValueRef::Num(n))) => match n {
170                Num::Unsigned(_) => self.deserialize_u64(visitor),
171                Num::Signed(_) => self.deserialize_i64(visitor),
172                Num::F32(_) => self.deserialize_f32(visitor),
173                Num::F64(_) => self.deserialize_f64(visitor),
174            },
175            Some(MetaValue::O(Value::Arr(_)))
176            | Some(MetaValue::R(ValueRef::Arr(_))) => {
177                self.deserialize_seq(visitor)
178            }
179            Some(MetaValue::O(Value::Map(_)))
180            | Some(MetaValue::R(ValueRef::Map(_))) => {
181                self.deserialize_map(visitor)
182            }
183            Some(MetaValue::O(Value::Str(_))) => {
184                self.deserialize_string(visitor)
185            }
186            Some(MetaValue::R(ValueRef::Str(_))) => {
187                self.deserialize_str(visitor)
188            }
189            Some(MetaValue::O(Value::Bin(_))) => {
190                self.deserialize_byte_buf(visitor)
191            }
192            Some(MetaValue::R(ValueRef::Bin(_))) => {
193                self.deserialize_bytes(visitor)
194            }
195            Some(MetaValue::O(Value::Ext(_, _)))
196            | Some(MetaValue::R(ValueRef::Ext(_, _))) => {
197                self.deserialize_newtype_struct(EXT_STRUCT_NAME, visitor)
198            }
199            None => Err(Error::EDecode {
200                expected: "any".into(),
201                got: "no data".into(),
202            }),
203        }
204    }
205
206    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
207    where
208        V: de::Visitor<'de>,
209    {
210        match self.0.take() {
211            Some(MetaValue::O(Value::Bool(b)))
212            | Some(MetaValue::R(ValueRef::Bool(b))) => visitor.visit_bool(b),
213            oth => Err(Error::EDecode {
214                expected: "bool".into(),
215                got: format!("{:?}", oth),
216            }),
217        }
218    }
219
220    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
221    where
222        V: de::Visitor<'de>,
223    {
224        match self.0.take() {
225            Some(MetaValue::O(Value::Num(n)))
226            | Some(MetaValue::R(ValueRef::Num(n)))
227                if n.fits::<i8>() =>
228            {
229                visitor.visit_i8(n.to())
230            }
231            oth => Err(Error::EDecode {
232                expected: "i8".into(),
233                got: format!("{:?}", oth),
234            }),
235        }
236    }
237
238    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
239    where
240        V: de::Visitor<'de>,
241    {
242        match self.0.take() {
243            Some(MetaValue::O(Value::Num(n)))
244            | Some(MetaValue::R(ValueRef::Num(n)))
245                if n.fits::<i16>() =>
246            {
247                visitor.visit_i16(n.to())
248            }
249            oth => Err(Error::EDecode {
250                expected: "i16".into(),
251                got: format!("{:?}", oth),
252            }),
253        }
254    }
255
256    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
257    where
258        V: de::Visitor<'de>,
259    {
260        match self.0.take() {
261            Some(MetaValue::O(Value::Num(n)))
262            | Some(MetaValue::R(ValueRef::Num(n)))
263                if n.fits::<i32>() =>
264            {
265                visitor.visit_i32(n.to())
266            }
267            oth => Err(Error::EDecode {
268                expected: "i32".into(),
269                got: format!("{:?}", oth),
270            }),
271        }
272    }
273
274    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
275    where
276        V: de::Visitor<'de>,
277    {
278        match self.0.take() {
279            Some(MetaValue::O(Value::Num(n)))
280            | Some(MetaValue::R(ValueRef::Num(n)))
281                if n.fits::<i64>() =>
282            {
283                visitor.visit_i64(n.to())
284            }
285            oth => Err(Error::EDecode {
286                expected: "i64".into(),
287                got: format!("{:?}", oth),
288            }),
289        }
290    }
291
292    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
293    where
294        V: de::Visitor<'de>,
295    {
296        match self.0.take() {
297            Some(MetaValue::O(Value::Num(n)))
298            | Some(MetaValue::R(ValueRef::Num(n)))
299                if n.fits::<u8>() =>
300            {
301                visitor.visit_u8(n.to())
302            }
303            oth => Err(Error::EDecode {
304                expected: "u8".into(),
305                got: format!("{:?}", oth),
306            }),
307        }
308    }
309
310    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
311    where
312        V: de::Visitor<'de>,
313    {
314        match self.0.take() {
315            Some(MetaValue::O(Value::Num(n)))
316            | Some(MetaValue::R(ValueRef::Num(n)))
317                if n.fits::<u16>() =>
318            {
319                visitor.visit_u16(n.to())
320            }
321            oth => Err(Error::EDecode {
322                expected: "u16".into(),
323                got: format!("{:?}", oth),
324            }),
325        }
326    }
327
328    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
329    where
330        V: de::Visitor<'de>,
331    {
332        match self.0.take() {
333            Some(MetaValue::O(Value::Num(n)))
334            | Some(MetaValue::R(ValueRef::Num(n)))
335                if n.fits::<u32>() =>
336            {
337                visitor.visit_u32(n.to())
338            }
339            oth => Err(Error::EDecode {
340                expected: "u32".into(),
341                got: format!("{:?}", oth),
342            }),
343        }
344    }
345
346    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
347    where
348        V: de::Visitor<'de>,
349    {
350        match self.0.take() {
351            Some(MetaValue::O(Value::Num(n)))
352            | Some(MetaValue::R(ValueRef::Num(n)))
353                if n.fits::<u64>() =>
354            {
355                visitor.visit_u64(n.to())
356            }
357            oth => Err(Error::EDecode {
358                expected: "u64".into(),
359                got: format!("{:?}", oth),
360            }),
361        }
362    }
363
364    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
365    where
366        V: de::Visitor<'de>,
367    {
368        match self.0.take() {
369            Some(MetaValue::O(Value::Num(n)))
370            | Some(MetaValue::R(ValueRef::Num(n)))
371                if n.fits::<f32>() =>
372            {
373                visitor.visit_f32(n.to())
374            }
375            oth => Err(Error::EDecode {
376                expected: "f32".into(),
377                got: format!("{:?}", oth),
378            }),
379        }
380    }
381
382    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
383    where
384        V: de::Visitor<'de>,
385    {
386        match self.0.take() {
387            Some(MetaValue::O(Value::Num(n)))
388            | Some(MetaValue::R(ValueRef::Num(n)))
389                if n.fits::<f64>() =>
390            {
391                visitor.visit_f64(n.to())
392            }
393            oth => Err(Error::EDecode {
394                expected: "f64".into(),
395                got: format!("{:?}", oth),
396            }),
397        }
398    }
399
400    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
401    where
402        V: de::Visitor<'de>,
403    {
404        match (|this: Self| {
405            let o = this.0.take();
406            let s = match &o {
407                Some(MetaValue::O(Value::Str(s))) => s.as_str(),
408                Some(MetaValue::R(ValueRef::Str(s))) => s.as_str(),
409                _ => return Err(o),
410            };
411            let s = match s {
412                Ok(s) => s,
413                Err(_) => return Err(o),
414            };
415            let mut iter = s.chars();
416            // get the first character
417            let c = match iter.next() {
418                Some(c) => c,
419                None => return Err(o),
420            };
421            // make sure there are no more
422            match iter.next() {
423                None => Ok(c),
424                Some(_) => Err(o),
425            }
426        })(self)
427        {
428            Ok(c) => visitor.visit_char(c),
429            Err(o) => Err(Error::EDecode {
430                expected: "char".into(),
431                got: format!("{:?}", o),
432            }),
433        }
434    }
435
436    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
437    where
438        V: de::Visitor<'de>,
439    {
440        use crate::value::Utf8Str;
441        match self.0.take() {
442            Some(MetaValue::O(Value::Str(Utf8Str(data)))) => {
443                let data = Vec::from(data);
444                match String::from_utf8(data) {
445                    Ok(s) => visitor.visit_string(s),
446                    Err(e) => visitor.visit_byte_buf(e.into_bytes()),
447                }
448            }
449            Some(MetaValue::R(ValueRef::Str(s))) => match s.as_str() {
450                Ok(s) => visitor.visit_borrowed_str(s),
451                Err(_) => visitor.visit_borrowed_bytes(s.as_bytes()),
452            },
453            oth => Err(Error::EDecode {
454                expected: "str".into(),
455                got: format!("{:?}", oth),
456            }),
457        }
458    }
459
460    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
461    where
462        V: de::Visitor<'de>,
463    {
464        self.deserialize_str(visitor)
465    }
466
467    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
468    where
469        V: de::Visitor<'de>,
470    {
471        match self.0.take() {
472            Some(MetaValue::O(Value::Bin(data))) => {
473                visitor.visit_byte_buf(Vec::from(data))
474            }
475            Some(MetaValue::R(ValueRef::Bin(data))) => {
476                visitor.visit_borrowed_bytes(data)
477            }
478            oth => Err(Error::EDecode {
479                expected: "bin".into(),
480                got: format!("{:?}", oth),
481            }),
482        }
483    }
484
485    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
486    where
487        V: de::Visitor<'de>,
488    {
489        self.deserialize_bytes(visitor)
490    }
491
492    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
493    where
494        V: de::Visitor<'de>,
495    {
496        match &self.0 {
497            Some(MetaValue::O(Value::Nil))
498            | Some(MetaValue::R(ValueRef::Nil)) => visitor.visit_none(),
499            _ => visitor.visit_some(self),
500        }
501    }
502
503    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
504    where
505        V: de::Visitor<'de>,
506    {
507        match self.0.take() {
508            Some(MetaValue::O(Value::Nil))
509            | Some(MetaValue::R(ValueRef::Nil)) => visitor.visit_unit(),
510            oth => Err(Error::EDecode {
511                expected: "unit".into(),
512                got: format!("{:?}", oth),
513            }),
514        }
515    }
516
517    fn deserialize_unit_struct<V>(
518        self,
519        _name: &'static str,
520        visitor: V,
521    ) -> Result<V::Value>
522    where
523        V: de::Visitor<'de>,
524    {
525        self.deserialize_unit(visitor)
526    }
527
528    fn deserialize_newtype_struct<V>(
529        self,
530        name: &'static str,
531        visitor: V,
532    ) -> Result<V::Value>
533    where
534        V: de::Visitor<'de>,
535    {
536        if name == EXT_STRUCT_NAME {
537            match self.0.take() {
538                Some(MetaValue::O(Value::Ext(t, data))) => {
539                    self.0.replace(MetaValue::O(Value::Arr(vec![
540                        Value::Num(t.into()),
541                        Value::Bin(data),
542                    ])));
543                }
544                Some(MetaValue::R(ValueRef::Ext(t, data))) => {
545                    self.0.replace(MetaValue::R(ValueRef::Arr(vec![
546                        ValueRef::Num(t.into()),
547                        ValueRef::Bin(data),
548                    ])));
549                }
550                Some(oth) => {
551                    self.0.replace(oth);
552                }
553                _ => (),
554            }
555        }
556
557        visitor.visit_newtype_struct(self)
558    }
559
560    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
561    where
562        V: de::Visitor<'de>,
563    {
564        match self.0.take() {
565            Some(MetaValue::O(Value::Arr(arr))) => {
566                visitor.visit_seq(Seq(arr.into_iter().map(MetaValue::O)))
567            }
568            Some(MetaValue::R(ValueRef::Arr(arr))) => {
569                visitor.visit_seq(Seq(arr.into_iter().map(MetaValue::R)))
570            }
571            oth => Err(Error::EDecode {
572                expected: "seq".into(),
573                got: format!("{:?}", oth),
574            }),
575        }
576    }
577
578    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
579    where
580        V: de::Visitor<'de>,
581    {
582        self.deserialize_seq(visitor)
583    }
584
585    fn deserialize_tuple_struct<V>(
586        self,
587        _name: &'static str,
588        _len: usize,
589        visitor: V,
590    ) -> Result<V::Value>
591    where
592        V: de::Visitor<'de>,
593    {
594        self.deserialize_seq(visitor)
595    }
596
597    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
598    where
599        V: de::Visitor<'de>,
600    {
601        // bit of a hack - convert the map (k, v) tuples into just a flat
602        // sequence so we can use the same access iterator
603        match self.0.take() {
604            Some(MetaValue::O(Value::Map(map))) => visitor.visit_map(Seq(map
605                .into_iter()
606                .flat_map(|(k, v)| [MetaValue::O(k), MetaValue::O(v)]))),
607            Some(MetaValue::R(ValueRef::Map(map))) => visitor
608                .visit_map(Seq(map
609                    .into_iter()
610                    .flat_map(|(k, v)| [MetaValue::R(k), MetaValue::R(v)]))),
611            oth => Err(Error::EDecode {
612                expected: "map".into(),
613                got: format!("{:?}", oth),
614            }),
615        }
616    }
617
618    fn deserialize_struct<V>(
619        self,
620        _name: &'static str,
621        _fields: &'static [&'static str],
622        visitor: V,
623    ) -> Result<V::Value>
624    where
625        V: de::Visitor<'de>,
626    {
627        self.deserialize_map(visitor)
628    }
629
630    fn deserialize_enum<V>(
631        self,
632        _name: &'static str,
633        _variants: &'static [&'static str],
634        visitor: V,
635    ) -> Result<V::Value>
636    where
637        V: de::Visitor<'de>,
638    {
639        use de::IntoDeserializer;
640        match self.0.take() {
641            Some(MetaValue::O(Value::Str(s))) => match s.as_str() {
642                Ok(s) => visitor.visit_enum(s.into_deserializer()),
643                Err(_) => Err(Error::EDecode {
644                    expected: "utf8 str".into(),
645                    got: "non-utf8 bytes".into(),
646                }),
647            },
648            Some(MetaValue::R(ValueRef::Str(s))) => match s.as_str() {
649                Ok(s) => visitor.visit_enum(s.into_deserializer()),
650                Err(_) => Err(Error::EDecode {
651                    expected: "utf8 str".into(),
652                    got: "non-utf8 bytes".into(),
653                }),
654            },
655            Some(MetaValue::O(Value::Map(mut map))) if map.len() == 1 => {
656                let (k, v) = map.remove(0);
657                visitor.visit_enum(Enum(
658                    Some(MetaValue::O(k)),
659                    Some(MetaValue::O(v)),
660                ))
661            }
662            Some(MetaValue::R(ValueRef::Map(mut map))) if map.len() == 1 => {
663                let (k, v) = map.remove(0);
664                visitor.visit_enum(Enum(
665                    Some(MetaValue::R(k)),
666                    Some(MetaValue::R(v)),
667                ))
668            }
669            oth => Err(Error::EDecode {
670                expected: "str or map(len == 1)".into(),
671                got: format!("{:?}", oth),
672            }),
673        }
674    }
675
676    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
677    where
678        V: de::Visitor<'de>,
679    {
680        self.deserialize_str(visitor)
681    }
682
683    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
684    where
685        V: de::Visitor<'de>,
686    {
687        self.deserialize_any(visitor)
688    }
689}
690
691struct Seq<'de, I: Iterator<Item = MetaValue<'de>>>(I);
692
693impl<'de, I: Iterator<Item = MetaValue<'de>>> de::SeqAccess<'de>
694    for Seq<'de, I>
695{
696    type Error = Error;
697
698    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
699    where
700        T: de::DeserializeSeed<'de>,
701    {
702        match self.0.next() {
703            None => Ok(None),
704            Some(v) => {
705                let mut d = DeserializerSync(Some(v));
706                seed.deserialize(&mut d).map(Some)
707            }
708        }
709    }
710}
711
712// this is a bit of a hack... but DRY : )
713impl<'de, I: Iterator<Item = MetaValue<'de>>> de::MapAccess<'de>
714    for Seq<'de, I>
715{
716    type Error = Error;
717
718    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
719    where
720        K: de::DeserializeSeed<'de>,
721    {
722        de::SeqAccess::next_element_seed(self, seed)
723    }
724
725    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
726    where
727        V: de::DeserializeSeed<'de>,
728    {
729        match de::SeqAccess::next_element_seed(self, seed)? {
730            Some(v) => Ok(v),
731            None => Err("expected value".into()),
732        }
733    }
734}
735
736struct Enum<'de>(Option<MetaValue<'de>>, Option<MetaValue<'de>>);
737
738impl<'de> de::EnumAccess<'de> for Enum<'de> {
739    type Error = Error;
740    type Variant = Self;
741
742    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant)>
743    where
744        V: de::DeserializeSeed<'de>,
745    {
746        let key = seed.deserialize(&mut DeserializerSync(self.0.take()))?;
747        Ok((key, self))
748    }
749}
750
751impl<'de> de::VariantAccess<'de> for Enum<'de> {
752    type Error = Error;
753
754    fn unit_variant(self) -> Result<()> {
755        // just ignoring any value that might have been placed here
756        Ok(())
757    }
758
759    fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value>
760    where
761        T: de::DeserializeSeed<'de>,
762    {
763        seed.deserialize(&mut DeserializerSync(self.1.take()))
764    }
765
766    fn tuple_variant<V>(mut self, _len: usize, visitor: V) -> Result<V::Value>
767    where
768        V: de::Visitor<'de>,
769    {
770        de::Deserializer::deserialize_seq(
771            &mut DeserializerSync(self.1.take()),
772            visitor,
773        )
774    }
775
776    fn struct_variant<V>(
777        mut self,
778        _fields: &'static [&'static str],
779        visitor: V,
780    ) -> Result<V::Value>
781    where
782        V: de::Visitor<'de>,
783    {
784        de::Deserializer::deserialize_map(
785            &mut DeserializerSync(self.1.take()),
786            visitor,
787        )
788    }
789}
msgpackin/de.rs

msgpackin/
de.rs
