messagepack_serde/value/
de.rs

1use crate::value::{Number, Value, ValueRef};
2use serde::{
3    de::{self},
4    forward_to_deserialize_any,
5};
6
7type Error = crate::de::Error<core::convert::Infallible>;
8
9fn visit_number<'de, V>(visitor: V, number: Number) -> Result<V::Value, Error>
10where
11    V: de::Visitor<'de>,
12{
13    match number {
14        Number::PositiveInt(i) => visitor.visit_u64(i),
15        Number::NegativeInt(i) => visitor.visit_i64(i),
16        Number::Float(f) => visitor.visit_f64(f),
17    }
18}
19
20mod value_ref {
21    use super::*;
22    impl<'de> de::Deserializer<'de> for &'de Value {
23        type Error = Error;
24        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
25        where
26            V: de::Visitor<'de>,
27        {
28            match self {
29                Value::Nil => visitor.visit_unit(),
30                Value::Bool(v) => visitor.visit_bool(*v),
31                Value::Bin(items) => visitor.visit_borrowed_bytes(items),
32                Value::Extension(extension_owned) => {
33                    // Bridge to the extension helper using a newtype struct
34                    let ext = extension_owned.as_ref();
35                    de::Deserializer::deserialize_newtype_struct(
36                        ExtRefDeserializer { ext },
37                        crate::extension::EXTENSION_STRUCT_NAME,
38                        visitor,
39                    )
40                }
41                Value::Number(number) => visit_number(visitor, *number),
42                Value::String(s) => visitor.visit_borrowed_str(s.as_str()),
43                Value::Array(values) => {
44                    let seq = SeqRefAccess::new(values.iter());
45                    visitor.visit_seq(seq)
46                }
47                Value::Map(items) => {
48                    let map = MapRefAccess::new(items.iter());
49                    visitor.visit_map(map)
50                }
51            }
52        }
53
54        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
55        where
56            V: de::Visitor<'de>,
57        {
58            match self {
59                Value::Nil => visitor.visit_none(),
60                _ => visitor.visit_some(self),
61            }
62        }
63
64        fn deserialize_enum<V>(
65            self,
66            _name: &'static str,
67            _variants: &'static [&'static str],
68            visitor: V,
69        ) -> Result<V::Value, Self::Error>
70        where
71            V: de::Visitor<'de>,
72        {
73            let access = EnumRefAccess::new(self);
74            visitor.visit_enum(access)
75        }
76
77        forward_to_deserialize_any! {
78            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
79            bytes byte_buf unit unit_struct newtype_struct seq tuple
80            tuple_struct map struct identifier ignored_any
81        }
82    }
83
84    impl<'de> de::IntoDeserializer<'de, Error> for &'de Value {
85        type Deserializer = Self;
86        fn into_deserializer(self) -> Self::Deserializer {
87            self
88        }
89    }
90
91    struct SeqRefAccess<'de, I>
92    where
93        I: Iterator<Item = &'de Value> + ExactSizeIterator,
94    {
95        iter: I,
96    }
97
98    impl<'de, I> SeqRefAccess<'de, I>
99    where
100        I: Iterator<Item = &'de Value> + ExactSizeIterator,
101    {
102        fn new(iter: I) -> Self {
103            Self { iter }
104        }
105    }
106
107    impl<'de, I> de::SeqAccess<'de> for SeqRefAccess<'de, I>
108    where
109        I: Iterator<Item = &'de Value> + ExactSizeIterator,
110    {
111        type Error = Error;
112
113        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
114        where
115            T: de::DeserializeSeed<'de>,
116        {
117            match self.iter.next() {
118                Some(v) => seed.deserialize(v).map(Some),
119                None => Ok(None),
120            }
121        }
122
123        fn size_hint(&self) -> Option<usize> {
124            Some(self.iter.len())
125        }
126    }
127
128    struct MapRefAccess<'de, I>
129    where
130        I: Iterator<Item = &'de (Value, Value)> + ExactSizeIterator,
131    {
132        iter: I,
133        val: Option<&'de Value>,
134    }
135
136    impl<'de, I> MapRefAccess<'de, I>
137    where
138        I: Iterator<Item = &'de (Value, Value)> + ExactSizeIterator,
139    {
140        fn new(iter: I) -> Self {
141            Self { iter, val: None }
142        }
143    }
144
145    impl<'de, I> de::MapAccess<'de> for MapRefAccess<'de, I>
146    where
147        I: Iterator<Item = &'de (Value, Value)> + ExactSizeIterator,
148    {
149        type Error = Error;
150
151        fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
152        where
153            K: de::DeserializeSeed<'de>,
154        {
155            match self.iter.next() {
156                Some((key, value)) => {
157                    self.val = Some(value);
158                    seed.deserialize(key).map(Some)
159                }
160                None => Ok(None),
161            }
162        }
163
164        fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
165        where
166            V: de::DeserializeSeed<'de>,
167        {
168            match self.val.take() {
169                Some(val) => seed.deserialize(val),
170                None => Err(<Error as de::Error>::custom("value is missing")),
171            }
172        }
173
174        fn size_hint(&self) -> Option<usize> {
175            Some(self.iter.len())
176        }
177    }
178
179    struct EnumRefAccess<'de> {
180        val: &'de Value,
181    }
182
183    impl<'de> EnumRefAccess<'de> {
184        fn new(val: &'de Value) -> Self {
185            Self { val }
186        }
187    }
188
189    impl<'de> de::EnumAccess<'de> for EnumRefAccess<'de> {
190        type Error = Error;
191        type Variant = EnumRefVariant<'de>;
192        fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
193        where
194            V: de::DeserializeSeed<'de>,
195        {
196            match self.val {
197                Value::String(_) => {
198                    let id = seed.deserialize(self.val)?;
199                    Ok((id, EnumRefVariant::String))
200                }
201                // Map-tagged enum: { tag: content }
202                Value::Map(items) => match items.split_first() {
203                    Some((content, [])) => {
204                        let id = seed.deserialize(&content.0)?;
205                        Ok((id, EnumRefVariant::Value(&content.1)))
206                    }
207                    _ => Err(de::Error::invalid_length(items.len(), &"expect 1 element")),
208                },
209                _ => Err(de::Error::invalid_type(
210                    de::Unexpected::Other("non-enum value"),
211                    &"string or map for enum",
212                )),
213            }
214        }
215    }
216
217    enum EnumRefVariant<'de> {
218        String,
219        Value(&'de Value),
220    }
221
222    impl<'de> de::VariantAccess<'de> for EnumRefVariant<'de> {
223        type Error = Error;
224
225        fn unit_variant(self) -> Result<(), Self::Error> {
226            match self {
227                EnumRefVariant::String => Ok(()),
228                _ => Err(de::Error::invalid_type(
229                    de::Unexpected::Other("non-unit enum variant"),
230                    &"unit variant",
231                )),
232            }
233        }
234
235        fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
236        where
237            T: de::DeserializeSeed<'de>,
238        {
239            match self {
240                EnumRefVariant::Value(value) => seed.deserialize(value),
241                _ => Err(de::Error::invalid_type(
242                    de::Unexpected::Other("non-newtype enum variant"),
243                    &"array or map",
244                )),
245            }
246        }
247
248        fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
249        where
250            V: de::Visitor<'de>,
251        {
252            match self {
253                EnumRefVariant::Value(value) => de::Deserializer::deserialize_seq(value, visitor),
254                _ => Err(de::Error::invalid_type(
255                    de::Unexpected::Other("non-newtype enum variant"),
256                    &"array or map",
257                )),
258            }
259        }
260
261        fn struct_variant<V>(
262            self,
263            _fields: &'static [&'static str],
264            visitor: V,
265        ) -> Result<V::Value, Self::Error>
266        where
267            V: de::Visitor<'de>,
268        {
269            match self {
270                EnumRefVariant::Value(value) => de::Deserializer::deserialize_map(value, visitor),
271                _ => Err(de::Error::invalid_type(
272                    de::Unexpected::Other("non-map variant content"),
273                    &"map",
274                )),
275            }
276        }
277    }
278
279    struct ExtRefDeserializer<'de> {
280        ext: messagepack_core::extension::ExtensionRef<'de>,
281    }
282
283    impl<'de> de::Deserializer<'de> for ExtRefDeserializer<'de> {
284        type Error = Error;
285
286        fn deserialize_newtype_struct<V>(
287            self,
288            name: &'static str,
289            visitor: V,
290        ) -> Result<V::Value, Self::Error>
291        where
292            V: de::Visitor<'de>,
293        {
294            if name == crate::extension::EXTENSION_STRUCT_NAME {
295                visitor.visit_newtype_struct(ExtSeqRef { ext: self.ext })
296            } else {
297                Err(<Error as de::Error>::custom(
298                    "unexpected newtype name for extension",
299                ))
300            }
301        }
302
303        fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
304        where
305            V: de::Visitor<'de>,
306        {
307            Err(<Error as de::Error>::custom("invalid entry point"))
308        }
309
310        forward_to_deserialize_any! {
311            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
312            bytes byte_buf option unit unit_struct seq tuple tuple_struct map struct
313            enum identifier ignored_any
314        }
315    }
316
317    struct ExtSeqRef<'de> {
318        ext: messagepack_core::extension::ExtensionRef<'de>,
319    }
320
321    impl<'de> de::Deserializer<'de> for ExtSeqRef<'de> {
322        type Error = Error;
323
324        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
325        where
326            V: de::Visitor<'de>,
327        {
328            struct Access<'de> {
329                ext: messagepack_core::extension::ExtensionRef<'de>,
330                idx: u8,
331            }
332
333            impl<'de> de::SeqAccess<'de> for Access<'de> {
334                type Error = Error;
335                fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
336                where
337                    T: de::DeserializeSeed<'de>,
338                {
339                    match self.idx {
340                        0 => {
341                            self.idx = 1;
342                            let de =
343                                serde::de::value::I8Deserializer::<Error>::new(self.ext.r#type);
344                            let v = seed.deserialize(de)?;
345                            Ok(Some(v))
346                        }
347                        1 => {
348                            self.idx = 2;
349                            let de = serde::de::value::BorrowedBytesDeserializer::<Error>::new(
350                                self.ext.data,
351                            );
352                            let v = seed.deserialize(de)?;
353                            Ok(Some(v))
354                        }
355                        _ => Ok(None),
356                    }
357                }
358            }
359
360            visitor.visit_seq(Access {
361                ext: self.ext,
362                idx: 0,
363            })
364        }
365
366        fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
367        where
368            V: de::Visitor<'de>,
369        {
370            Err(<Error as de::Error>::custom("invalid entry point"))
371        }
372
373        forward_to_deserialize_any! {
374            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
375            bytes byte_buf option unit unit_struct newtype_struct tuple tuple_struct
376            map struct enum identifier ignored_any
377        }
378    }
379
380    impl<'de> de::Deserializer<'de> for &ValueRef<'de> {
381        type Error = Error;
382
383        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
384        where
385            V: de::Visitor<'de>,
386        {
387            match self {
388                ValueRef::Nil => visitor.visit_unit(),
389                ValueRef::Bool(b) => visitor.visit_bool(*b),
390                ValueRef::Bin(b) => visitor.visit_borrowed_bytes(b),
391                ValueRef::Extension(ext) => de::Deserializer::deserialize_newtype_struct(
392                    ExtRefDeserializer { ext: *ext },
393                    crate::extension::EXTENSION_STRUCT_NAME,
394                    visitor,
395                ),
396                ValueRef::Number(n) => visit_number(visitor, *n),
397                ValueRef::String(s) => visitor.visit_borrowed_str(s),
398                ValueRef::Array(items) => {
399                    let seq = SeqAccessValueRefBorrowed { it: items.iter() };
400                    visitor.visit_seq(seq)
401                }
402                ValueRef::Map(items) => {
403                    let map = MapAccessValueRefBorrowed {
404                        it: items.iter(),
405                        val: None,
406                    };
407                    visitor.visit_map(map)
408                }
409            }
410        }
411
412        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
413        where
414            V: de::Visitor<'de>,
415        {
416            match self {
417                ValueRef::Nil => visitor.visit_none(),
418                _ => visitor.visit_some(self),
419            }
420        }
421
422        fn deserialize_enum<V>(
423            self,
424            _name: &'static str,
425            _variants: &'static [&'static str],
426            visitor: V,
427        ) -> Result<V::Value, Self::Error>
428        where
429            V: de::Visitor<'de>,
430        {
431            let access = EnumAccessBorrowedValueRef { val: self };
432            visitor.visit_enum(access)
433        }
434
435        forward_to_deserialize_any! {
436            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
437            bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
438            map struct identifier ignored_any
439        }
440    }
441
442    impl<'de> de::IntoDeserializer<'de, Error> for &ValueRef<'de> {
443        type Deserializer = Self;
444        fn into_deserializer(self) -> Self::Deserializer {
445            self
446        }
447    }
448
449    struct SeqAccessValueRefBorrowed<'a, 'de> {
450        it: core::slice::Iter<'a, ValueRef<'de>>,
451    }
452
453    impl<'a, 'de> de::SeqAccess<'de> for SeqAccessValueRefBorrowed<'a, 'de> {
454        type Error = Error;
455
456        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
457        where
458            T: de::DeserializeSeed<'de>,
459        {
460            match self.it.next() {
461                Some(v) => seed.deserialize(v).map(Some),
462                None => Ok(None),
463            }
464        }
465
466        fn size_hint(&self) -> Option<usize> {
467            Some(self.it.len())
468        }
469    }
470
471    struct MapAccessValueRefBorrowed<'a, 'de> {
472        it: core::slice::Iter<'a, (ValueRef<'de>, ValueRef<'de>)>,
473        val: Option<&'a ValueRef<'de>>,
474    }
475
476    impl<'a, 'de> de::MapAccess<'de> for MapAccessValueRefBorrowed<'a, 'de> {
477        type Error = Error;
478
479        fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
480        where
481            K: de::DeserializeSeed<'de>,
482        {
483            match self.it.next() {
484                Some((k, v)) => {
485                    self.val = Some(v);
486                    seed.deserialize(k).map(Some)
487                }
488                None => Ok(None),
489            }
490        }
491
492        fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
493        where
494            V: de::DeserializeSeed<'de>,
495        {
496            match self.val.take() {
497                Some(v) => seed.deserialize(v),
498                None => Err(<Error as de::Error>::custom("value is missing")),
499            }
500        }
501
502        fn size_hint(&self) -> Option<usize> {
503            Some(self.it.len())
504        }
505    }
506
507    struct EnumAccessBorrowedValueRef<'a, 'de> {
508        val: &'a ValueRef<'de>,
509    }
510
511    impl<'a, 'de> de::EnumAccess<'de> for EnumAccessBorrowedValueRef<'a, 'de> {
512        type Error = Error;
513        type Variant = VariantAccessBorrowedValueRef<'a, 'de>;
514
515        fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
516        where
517            V: de::DeserializeSeed<'de>,
518        {
519            match self.val {
520                ValueRef::String(tag) => {
521                    let de = serde::de::value::BorrowedStrDeserializer::<Error>::new(tag);
522                    let id = seed.deserialize(de)?;
523                    Ok((id, VariantAccessBorrowedValueRef::String))
524                }
525                ValueRef::Map(items) => match items.as_slice().split_first() {
526                    Some((first, [])) => {
527                        let id = seed.deserialize(&first.0)?;
528                        Ok((id, VariantAccessBorrowedValueRef::Value(&first.1)))
529                    }
530                    _ => Err(de::Error::invalid_length(items.len(), &"expect 1 element")),
531                },
532                _ => Err(de::Error::invalid_type(
533                    de::Unexpected::Other("non-enum value"),
534                    &"string or map for enum",
535                )),
536            }
537        }
538    }
539
540    enum VariantAccessBorrowedValueRef<'a, 'de> {
541        String,
542        Value(&'a ValueRef<'de>),
543    }
544
545    impl<'a, 'de> de::VariantAccess<'de> for VariantAccessBorrowedValueRef<'a, 'de> {
546        type Error = Error;
547
548        fn unit_variant(self) -> Result<(), Self::Error> {
549            match self {
550                VariantAccessBorrowedValueRef::String => Ok(()),
551                _ => Err(de::Error::invalid_type(
552                    de::Unexpected::Other("non-unit enum variant"),
553                    &"unit variant",
554                )),
555            }
556        }
557
558        fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
559        where
560            T: de::DeserializeSeed<'de>,
561        {
562            match self {
563                VariantAccessBorrowedValueRef::Value(v) => seed.deserialize(v),
564                _ => Err(de::Error::invalid_type(
565                    de::Unexpected::Other("non-newtype enum variant"),
566                    &"array or map",
567                )),
568            }
569        }
570
571        fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
572        where
573            V: de::Visitor<'de>,
574        {
575            match self {
576                VariantAccessBorrowedValueRef::Value(v) => {
577                    de::Deserializer::deserialize_seq(v, visitor)
578                }
579                _ => Err(de::Error::invalid_type(
580                    de::Unexpected::Other("non-newtype enum variant"),
581                    &"array or map",
582                )),
583            }
584        }
585
586        fn struct_variant<V>(
587            self,
588            _fields: &'static [&'static str],
589            visitor: V,
590        ) -> Result<V::Value, Self::Error>
591        where
592            V: de::Visitor<'de>,
593        {
594            match self {
595                VariantAccessBorrowedValueRef::Value(v) => {
596                    de::Deserializer::deserialize_map(v, visitor)
597                }
598                _ => Err(de::Error::invalid_type(
599                    de::Unexpected::Other("non-map variant content"),
600                    &"map",
601                )),
602            }
603        }
604    }
605}
606
607mod value_owned {
608    use super::*;
609
610    impl<'de> de::Deserializer<'de> for Value {
611        type Error = Error;
612
613        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
614        where
615            V: de::Visitor<'de>,
616        {
617            match self {
618                Value::Nil => visitor.visit_unit(),
619                Value::Bool(b) => visitor.visit_bool(b),
620                Value::Bin(b) => visitor.visit_byte_buf(b),
621                Value::Extension(ext) => de::Deserializer::deserialize_newtype_struct(
622                    ExtDeserializerOwned {
623                        kind: ext.r#type,
624                        data: ext.data,
625                    },
626                    crate::extension::EXTENSION_STRUCT_NAME,
627                    visitor,
628                ),
629                Value::Number(n) => visit_number(visitor, n),
630                Value::String(s) => visitor.visit_string(s),
631                Value::Array(items) => visitor.visit_seq(OwnedSeqAccess {
632                    it: items.into_iter(),
633                }),
634                Value::Map(items) => visitor.visit_map(OwnedMapAccess {
635                    it: items.into_iter(),
636                    pending_value: None,
637                }),
638            }
639        }
640
641        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
642        where
643            V: de::Visitor<'de>,
644        {
645            match self {
646                Value::Nil => visitor.visit_none(),
647                other => visitor.visit_some(other),
648            }
649        }
650
651        fn deserialize_enum<V>(
652            self,
653            _name: &'static str,
654            _variants: &'static [&'static str],
655            visitor: V,
656        ) -> Result<V::Value, Self::Error>
657        where
658            V: de::Visitor<'de>,
659        {
660            let access = EnumAccessOwned { val: self };
661            visitor.visit_enum(access)
662        }
663
664        forward_to_deserialize_any! {
665            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
666            bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
667            map struct identifier ignored_any
668        }
669    }
670
671    impl<'de> de::IntoDeserializer<'de, Error> for Value {
672        type Deserializer = Self;
673        fn into_deserializer(self) -> Self::Deserializer {
674            self
675        }
676    }
677
678    struct OwnedSeqAccess {
679        it: alloc::vec::IntoIter<Value>,
680    }
681
682    impl<'de> de::SeqAccess<'de> for OwnedSeqAccess {
683        type Error = Error;
684        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
685        where
686            T: de::DeserializeSeed<'de>,
687        {
688            match self.it.next() {
689                Some(v) => seed.deserialize(v).map(Some),
690                None => Ok(None),
691            }
692        }
693
694        fn size_hint(&self) -> Option<usize> {
695            Some(self.it.len())
696        }
697    }
698
699    struct OwnedMapAccess {
700        it: alloc::vec::IntoIter<(Value, Value)>,
701        pending_value: Option<Value>,
702    }
703
704    impl<'de> de::MapAccess<'de> for OwnedMapAccess {
705        type Error = Error;
706
707        fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
708        where
709            K: de::DeserializeSeed<'de>,
710        {
711            match self.it.next() {
712                Some((k, v)) => {
713                    self.pending_value = Some(v);
714                    seed.deserialize(k).map(Some)
715                }
716                None => Ok(None),
717            }
718        }
719
720        fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
721        where
722            V: de::DeserializeSeed<'de>,
723        {
724            let v = self
725                .pending_value
726                .take()
727                .ok_or_else(|| <Error as de::Error>::custom("value is missing for map key"))?;
728            seed.deserialize(v)
729        }
730
731        fn size_hint(&self) -> Option<usize> {
732            Some(self.it.len())
733        }
734    }
735
736    struct EnumAccessOwned {
737        val: Value,
738    }
739
740    enum VariantAccessOwned {
741        String,
742        Value(Value),
743    }
744
745    impl<'de> de::EnumAccess<'de> for EnumAccessOwned {
746        type Error = Error;
747        type Variant = VariantAccessOwned;
748
749        fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
750        where
751            V: de::DeserializeSeed<'de>,
752        {
753            match self.val {
754                Value::String(tag) => {
755                    let de = serde::de::value::StrDeserializer::<Error>::new(&tag);
756                    let id = seed.deserialize(de)?;
757                    Ok((id, VariantAccessOwned::String))
758                }
759                Value::Map(mut items) => {
760                    if items.len() != 1 {
761                        return Err(de::Error::invalid_length(
762                            items.len(),
763                            &"{variant: content}",
764                        ));
765                    }
766                    let (k, v) = items.remove(0);
767                    let id = seed.deserialize(k)?;
768                    Ok((id, VariantAccessOwned::Value(v)))
769                }
770                _other => Err(de::Error::invalid_type(
771                    de::Unexpected::Other("non-enum value"),
772                    &"string, or map for enum",
773                )),
774            }
775        }
776    }
777
778    impl<'de> de::VariantAccess<'de> for VariantAccessOwned {
779        type Error = Error;
780
781        fn unit_variant(self) -> Result<(), Self::Error> {
782            match self {
783                VariantAccessOwned::String => Ok(()),
784                _ => Err(de::Error::invalid_type(
785                    de::Unexpected::Other("non-unit enum variant"),
786                    &"unit variant",
787                )),
788            }
789        }
790
791        fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
792        where
793            T: de::DeserializeSeed<'de>,
794        {
795            match self {
796                Self::Value(v) => seed.deserialize(v),
797                _ => Err(de::Error::invalid_type(
798                    de::Unexpected::Other("non-newtype enum variant"),
799                    &"expect map",
800                )),
801            }
802        }
803
804        fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
805        where
806            V: de::Visitor<'de>,
807        {
808            match self {
809                Self::Value(v) => de::Deserializer::deserialize_seq(v, visitor),
810                _ => Err(de::Error::invalid_type(
811                    de::Unexpected::Other("non-seq variant content"),
812                    &"array",
813                )),
814            }
815        }
816
817        fn struct_variant<V>(
818            self,
819            _fields: &'static [&'static str],
820            visitor: V,
821        ) -> Result<V::Value, Self::Error>
822        where
823            V: de::Visitor<'de>,
824        {
825            match self {
826                Self::Value(v) => de::Deserializer::deserialize_map(v, visitor),
827                _ => Err(de::Error::invalid_type(
828                    de::Unexpected::Other("non-map variant content"),
829                    &"map",
830                )),
831            }
832        }
833    }
834
835    // Bridge for owned extension
836    struct ExtDeserializerOwned {
837        kind: i8,
838        data: alloc::vec::Vec<u8>,
839    }
840
841    impl<'de> de::Deserializer<'de> for ExtDeserializerOwned {
842        type Error = Error;
843
844        fn deserialize_newtype_struct<V>(
845            self,
846            name: &'static str,
847            visitor: V,
848        ) -> Result<V::Value, Self::Error>
849        where
850            V: de::Visitor<'de>,
851        {
852            if name == crate::extension::EXTENSION_STRUCT_NAME {
853                visitor.visit_newtype_struct(ExtSeqOwned {
854                    kind: self.kind,
855                    data: self.data,
856                })
857            } else {
858                Err(<Error as de::Error>::custom("invalid entry point"))
859            }
860        }
861
862        fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
863        where
864            V: de::Visitor<'de>,
865        {
866            Err(<Error as de::Error>::custom("invalid entry point"))
867        }
868
869        forward_to_deserialize_any! {
870            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
871            bytes byte_buf option unit unit_struct seq tuple tuple_struct map struct
872            enum identifier ignored_any
873        }
874    }
875
876    struct ExtSeqOwned {
877        kind: i8,
878        data: alloc::vec::Vec<u8>,
879    }
880
881    impl<'de> de::Deserializer<'de> for ExtSeqOwned {
882        type Error = Error;
883
884        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
885        where
886            V: de::Visitor<'de>,
887        {
888            struct Access {
889                kind: Option<i8>,
890                data: Option<alloc::vec::Vec<u8>>,
891            }
892            impl<'de> de::SeqAccess<'de> for Access {
893                type Error = Error;
894                fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
895                where
896                    T: de::DeserializeSeed<'de>,
897                {
898                    if let Some(k) = self.kind.take() {
899                        let de = serde::de::value::I8Deserializer::<Error>::new(k);
900                        let v = seed.deserialize(de)?;
901                        Ok(Some(v))
902                    } else if let Some(bytes) = self.data.take() {
903                        // Yield bytes as borrowed if possible; for simplicity, pass by bytes/byte_buf
904                        let v = seed.deserialize(BytesElemOwned(bytes))?;
905                        Ok(Some(v))
906                    } else {
907                        Ok(None)
908                    }
909                }
910            }
911            visitor.visit_seq(Access {
912                kind: Some(self.kind),
913                data: Some(self.data),
914            })
915        }
916
917        fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
918        where
919            V: de::Visitor<'de>,
920        {
921            Err(<Error as de::Error>::custom("invalid entry point"))
922        }
923
924        fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
925        where
926            V: de::Visitor<'de>,
927        {
928            self.deserialize_seq(visitor)
929        }
930
931        fn deserialize_tuple_struct<V>(
932            self,
933            _name: &'static str,
934            _len: usize,
935            visitor: V,
936        ) -> Result<V::Value, Self::Error>
937        where
938            V: de::Visitor<'de>,
939        {
940            self.deserialize_seq(visitor)
941        }
942
943        forward_to_deserialize_any! {
944            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
945            bytes byte_buf option unit unit_struct newtype_struct
946            map struct enum identifier ignored_any
947        }
948    }
949
950    // Minimal wrapper to feed byte content for owned extension
951    struct BytesElemOwned(alloc::vec::Vec<u8>);
952
953    impl<'de> de::Deserializer<'de> for BytesElemOwned {
954        type Error = Error;
955        fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
956        where
957            V: de::Visitor<'de>,
958        {
959            Err(<Error as de::Error>::custom("invalid entry point"))
960        }
961        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
962        where
963            V: de::Visitor<'de>,
964        {
965            visitor.visit_bytes(&self.0)
966        }
967        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
968        where
969            V: de::Visitor<'de>,
970        {
971            visitor.visit_byte_buf(self.0)
972        }
973        forward_to_deserialize_any! {
974            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
975            option unit unit_struct newtype_struct seq tuple tuple_struct map struct enum identifier ignored_any
976        }
977    }
978}
979
980#[cfg(test)]
981mod tests {
982    use super::*;
983    use rstest::rstest;
984    use serde::Deserialize;
985
986    #[derive(Deserialize, PartialEq, Debug)]
987    enum E {
988        Unit,
989        Newtype(u8),
990        Tuple(u8, bool),
991        Struct { a: bool },
992    }
993
994    #[rstest]
995    #[case(Value::from("Unit"), E::Unit)]
996    #[case(
997        Value::Map(vec![(Value::from("Newtype"), Value::from(27u64))]),
998        E::Newtype(27)
999    )]
1000    #[case(
1001        Value::Map(vec![(
1002            Value::from("Tuple"),
1003            Value::Array(vec![Value::from(3), Value::from(true)])
1004        )]),
1005        E::Tuple(3, true)
1006    )]
1007    #[case(
1008        Value::Map(vec![(
1009            Value::from("Struct"),
1010            Value::Map(vec![(Value::from("a"), Value::from(false))])
1011        )]),
1012        E::Struct { a: false }
1013    )]
1014    fn decode_enum(#[case] v: Value, #[case] expected: E) {
1015        let decoded = E::deserialize(&v).unwrap();
1016        assert_eq!(decoded, expected);
1017    }
1018
1019    // ---- Non-enum decode coverage (based on de/mod.rs tests) ----
1020    #[rstest]
1021    #[case(Value::from(true), true)]
1022    #[case(Value::from(false), false)]
1023    fn decode_bool(#[case] v: Value, #[case] expected: bool) {
1024        let decoded = bool::deserialize(&v).unwrap();
1025        assert_eq!(decoded, expected);
1026    }
1027
1028    #[rstest]
1029    #[case(Value::from(5u64), 5u8)]
1030    #[case(Value::from(128u64), 128u8)]
1031    fn decode_uint8(#[case] v: Value, #[case] expected: u8) {
1032        let decoded = u8::deserialize(&v).unwrap();
1033        assert_eq!(decoded, expected);
1034    }
1035
1036    #[rstest]
1037    fn decode_float_vec() {
1038        let v = Value::Array(vec![
1039            Value::from(1.1f64),
1040            Value::from(1.2f64),
1041            Value::from(1.3f64),
1042            Value::from(1.4f64),
1043            Value::from(1.5f64),
1044        ]);
1045        let decoded = Vec::<f64>::deserialize(&v).unwrap();
1046        assert_eq!(decoded, vec![1.1, 1.2, 1.3, 1.4, 1.5]);
1047    }
1048
1049    #[rstest]
1050    fn decode_struct() {
1051        #[derive(Deserialize, Debug, PartialEq)]
1052        struct S {
1053            compact: bool,
1054            schema: u8,
1055        }
1056        let v = Value::Map(vec![
1057            (Value::from("compact"), Value::from(true)),
1058            (Value::from("schema"), Value::from(0u64)),
1059        ]);
1060        let decoded = S::deserialize(&v).unwrap();
1061        assert_eq!(
1062            decoded,
1063            S {
1064                compact: true,
1065                schema: 0
1066            }
1067        );
1068    }
1069
1070    #[rstest]
1071    fn decode_struct_from_array() {
1072        #[derive(Deserialize, Debug, PartialEq)]
1073        struct S {
1074            compact: bool,
1075            schema: u8,
1076        }
1077        let v = Value::Array(vec![Value::from(true), Value::from(0u64)]);
1078        let decoded = S::deserialize(&v).unwrap();
1079        assert_eq!(
1080            decoded,
1081            S {
1082                compact: true,
1083                schema: 0
1084            }
1085        );
1086    }
1087
1088    #[rstest]
1089    fn option_consumes_nil_in_sequence() {
1090        let v = Value::Array(vec![Value::Nil, Value::from(5u64)]);
1091        let decoded = <(Option<u8>, u8)>::deserialize(&v).unwrap();
1092        assert_eq!(decoded, (None, 5));
1093    }
1094
1095    #[rstest]
1096    fn option_some_simple() {
1097        let v = Value::from(5u64);
1098        let decoded = Option::<u8>::deserialize(&v).unwrap();
1099        assert_eq!(decoded, Some(5));
1100    }
1101
1102    #[rstest]
1103    fn unit_from_nil() {
1104        let v = Value::Nil;
1105        let _: () = <()>::deserialize(&v).unwrap();
1106    }
1107
1108    #[rstest]
1109    fn unit_struct() {
1110        #[derive(Debug, Deserialize, PartialEq)]
1111        struct U;
1112        let v = Value::Nil;
1113        let decoded = U::deserialize(&v).unwrap();
1114        assert_eq!(decoded, U);
1115    }
1116
1117    #[derive(Deserialize, PartialEq, Debug)]
1118    #[serde(untagged)]
1119    enum Untagged {
1120        Bool(bool),
1121        U8(u8),
1122        Pair(u8, bool),
1123        Struct { a: bool },
1124        Nested(E),
1125    }
1126
1127    #[rstest]
1128    #[case(Value::from(true), Untagged::Bool(true))]
1129    #[case(Value::from(5u64), Untagged::U8(5))]
1130    #[case(Value::Array(vec![Value::from(2u64), Value::from(true)]), Untagged::Pair(2,true))]
1131    #[case(Value::Map(vec![(Value::from("a"), Value::from(false))]), Untagged::Struct { a: false })]
1132    #[case(Value::from("Unit"), Untagged::Nested(E::Unit))]
1133    fn decode_untagged(#[case] v: Value, #[case] expected: Untagged) {
1134        let decoded = Untagged::deserialize(&v).unwrap();
1135        assert_eq!(decoded, expected);
1136    }
1137
1138    // -------- Extension tests --------
1139    use messagepack_core::extension::{ExtensionOwned, ExtensionRef, FixedExtension};
1140
1141    #[derive(Deserialize, Debug, PartialEq)]
1142    struct WrapRef<'a>(#[serde(with = "crate::extension::ext_ref", borrow)] ExtensionRef<'a>);
1143
1144    #[rstest]
1145    fn decode_extension_ref_from_value() {
1146        let kind: i8 = 7;
1147        let data = vec![0x10, 0x20, 0x30];
1148        let v = Value::Extension(ExtensionOwned {
1149            r#type: kind,
1150            data: data.clone(),
1151        });
1152        let WrapRef(ext) = WrapRef::deserialize(&v).unwrap();
1153        assert_eq!(ext.r#type, kind);
1154        assert_eq!(ext.data, &data[..]);
1155    }
1156
1157    #[derive(Deserialize, Debug, PartialEq)]
1158    struct WrapOwned(#[serde(with = "crate::extension::ext_owned")] ExtensionOwned);
1159
1160    #[rstest]
1161    fn decode_extension_owned_from_value() {
1162        let kind: i8 = 10;
1163        let data = vec![0xAA, 0xBB, 0xCC, 0xDD];
1164        let v = Value::Extension(ExtensionOwned {
1165            r#type: kind,
1166            data: data.clone(),
1167        });
1168        let WrapOwned(ext) = WrapOwned::deserialize(&v).unwrap();
1169        assert_eq!(ext.r#type, kind);
1170        assert_eq!(ext.data, data);
1171    }
1172
1173    #[derive(Deserialize, Debug, PartialEq)]
1174    struct WrapFixed<const N: usize>(
1175        #[serde(with = "crate::extension::ext_fixed")] FixedExtension<N>,
1176    );
1177
1178    #[rstest]
1179    fn decode_extension_fixed_from_value() {
1180        let kind: i8 = 12;
1181        let data = vec![0xDE, 0xAD, 0xBE, 0xEF];
1182        let v = Value::Extension(ExtensionOwned {
1183            r#type: kind,
1184            data: data.clone(),
1185        });
1186        let WrapFixed::<8>(ext) = WrapFixed::<8>::deserialize(&v).unwrap();
1187        assert_eq!(ext.r#type, kind);
1188        assert_eq!(ext.as_slice(), &data[..]);
1189    }
1190
1191    // ---- Zero-copy efficiency tests for owned Value ----
1192    #[rstest]
1193    fn bin_zero_copy_into_bytebuf() {
1194        let mut buf = vec![0u8; 256];
1195        for (i, b) in buf.iter_mut().enumerate() {
1196            *b = (i as u8) ^ 0x5A;
1197        }
1198        let ptr = buf.as_ptr() as usize;
1199        let cap = buf.capacity();
1200        let v = Value::Bin(buf);
1201
1202        let bb = serde_bytes::ByteBuf::deserialize(v).unwrap();
1203        let moved = bb.into_vec();
1204        assert_eq!(moved.len(), 256);
1205        assert_eq!(moved.capacity(), cap);
1206        assert_eq!(moved.as_ptr() as usize, ptr);
1207    }
1208
1209    #[derive(Deserialize, Debug)]
1210    #[serde(rename = "$__MSGPACK_EXTENSION_STRUCT")]
1211    struct ExtBuf((i8, serde_bytes::ByteBuf));
1212
1213    #[rstest]
1214    fn extension_zero_copy_into_bytebuf_newtype() {
1215        let kind: i8 = 42;
1216        let mut data = vec![0u8; 128];
1217        for (i, b) in data.iter_mut().enumerate() {
1218            *b = (i as u8) ^ 0xA5;
1219        }
1220        let ptr = data.as_ptr() as usize;
1221        let cap = data.capacity();
1222
1223        // Owned Value with Extension
1224        let v = Value::Extension(ExtensionOwned { r#type: kind, data });
1225
1226        // Decode into a custom newtype that accepts (i8, ByteBuf) inside the extension newtype
1227        let ExtBuf((ty, bb)) = ExtBuf::deserialize(v).unwrap();
1228        assert_eq!(ty, kind);
1229        let moved = bb.into_vec();
1230        assert_eq!(moved.len(), 128);
1231        assert_eq!(moved.capacity(), cap);
1232        assert_eq!(moved.as_ptr() as usize, ptr);
1233    }
1234
1235    #[rstest]
1236    #[case(true)]
1237    #[case(false)]
1238    fn vref_decode_bool(#[case] expected: bool) {
1239        let v = ValueRef::Bool(expected);
1240        let b = bool::deserialize(&v).unwrap();
1241        assert_eq!(b, expected);
1242    }
1243
1244    #[rstest]
1245    #[case(5u64, 5u8)]
1246    #[case(128u64, 128u8)]
1247    fn vref_decode_u8(#[case] input: u64, #[case] expected: u8) {
1248        let v = ValueRef::from(input);
1249        let n = u8::deserialize(&v).unwrap();
1250        assert_eq!(n, expected);
1251    }
1252
1253    #[rstest]
1254    #[case(1.5f64)]
1255    #[case(0.0f64)]
1256    fn vref_decode_f64(#[case] input: f64) {
1257        let v = ValueRef::from(input);
1258        let f = f64::deserialize(&v).unwrap();
1259        assert_eq!(f, input);
1260    }
1261
1262    #[rstest]
1263    #[case("hello")]
1264    #[case("")]
1265    fn vref_decode_borrowed_str(#[case] s: &'static str) {
1266        let v = ValueRef::String(s);
1267        let out = <&str>::deserialize(&v).unwrap();
1268        assert_eq!(out, s);
1269        assert_eq!(out.as_ptr(), s.as_ptr());
1270    }
1271
1272    #[rstest]
1273    #[case(b"world".as_slice())]
1274    #[case(b"".as_slice())]
1275    fn vref_decode_borrowed_bytes(#[case] bytes: &'static [u8]) {
1276        let v = ValueRef::Bin(bytes);
1277        let out = <&[u8]>::deserialize(&v).unwrap();
1278        assert_eq!(out, bytes);
1279        assert_eq!(out.as_ptr(), bytes.as_ptr());
1280    }
1281
1282    #[rstest]
1283    fn vref_decode_vec_and_struct() {
1284        #[derive(Deserialize, Debug, PartialEq)]
1285        struct S {
1286            compact: bool,
1287            schema: u8,
1288        }
1289
1290        let v = ValueRef::Array(vec![ValueRef::from(true), ValueRef::from(0u64)]);
1291        let s = S::deserialize(&v).unwrap();
1292        assert_eq!(
1293            s,
1294            S {
1295                compact: true,
1296                schema: 0,
1297            }
1298        );
1299
1300        let v = ValueRef::Array(vec![
1301            ValueRef::from(1.1f64),
1302            ValueRef::from(1.2f64),
1303            ValueRef::from(1.3f64),
1304        ]);
1305        let out = Vec::<f64>::deserialize(&v).unwrap();
1306        assert_eq!(out, vec![1.1, 1.2, 1.3]);
1307    }
1308
1309    #[rstest]
1310    #[case(ValueRef::from("Unit"), E::Unit)]
1311    #[case(ValueRef::Map(vec![(ValueRef::from("Newtype"), ValueRef::from(27u64))]), E::Newtype(27))]
1312    #[case(
1313        ValueRef::Map(vec![(
1314            ValueRef::from("Tuple"),
1315            ValueRef::Array(vec![ValueRef::from(3u64), ValueRef::from(true)]),
1316        )]),
1317        E::Tuple(3, true)
1318    )]
1319    #[case(
1320        ValueRef::Map(vec![(
1321            ValueRef::from("Struct"),
1322            ValueRef::Map(vec![(ValueRef::from("a"), ValueRef::from(false))]),
1323        )]),
1324        E::Struct { a: false }
1325    )]
1326    fn vref_decode_enum(#[case] v: ValueRef<'_>, #[case] expected: E) {
1327        let decoded = E::deserialize(&v).unwrap();
1328        assert_eq!(decoded, expected);
1329    }
1330
1331    #[rstest]
1332    #[case(5u64, Some(5u8))]
1333    #[case(255u64, Some(255u8))]
1334    fn vref_decode_option_some(#[case] input: u64, #[case] expected: Option<u8>) {
1335        let v = ValueRef::from(input);
1336        let o = Option::<u8>::deserialize(&v).unwrap();
1337        assert_eq!(o, expected);
1338    }
1339
1340    #[test]
1341    fn vref_option_consumes_nil_in_sequence() {
1342        let v = ValueRef::Array(vec![ValueRef::Nil, ValueRef::from(5u64)]);
1343        let out = <(Option<u8>, u8)>::deserialize(&v).unwrap();
1344        assert_eq!(out, (None, 5));
1345    }
1346
1347    #[test]
1348    fn vref_decode_extension_ref() {
1349        use messagepack_core::extension::ExtensionRef;
1350
1351        #[derive(Deserialize, Debug, PartialEq)]
1352        struct WrapRef<'a>(#[serde(with = "crate::extension::ext_ref", borrow)] ExtensionRef<'a>);
1353
1354        let kind: i8 = 7;
1355        let data: &'static [u8] = &[0x10, 0x20, 0x30];
1356        let v = ValueRef::Extension(ExtensionRef::new(kind, data));
1357        let WrapRef(ext) = WrapRef::deserialize(&v).unwrap();
1358        assert_eq!(ext.r#type, kind);
1359        assert_eq!(ext.data, data);
1360    }
1361}
messagepack_serde/value/de.rs

messagepack_serde/value/
de.rs
