serde_encom/value/
des.rs

1use super::Map;
2use super::Number;
3use super::Value;
4use crate::error::{Error, ErrorCode};
5use crate::seed::BytesSeed;
6use crate::seed::StrSeed;
7use crate::seed::U64Seed;
8use alloc::borrow::{Cow, ToOwned};
9use alloc::string::String;
10#[cfg(feature = "raw_value")]
11use alloc::string::ToString;
12use alloc::vec::{self, Vec};
13use core::fmt;
14use core::slice;
15use core::str::FromStr;
16use serde::de::{
17    self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
18    SeqAccess, Unexpected, VariantAccess, Visitor,
19};
20use serde::forward_to_deserialize_any;
21
22#[cfg(feature = "arbitrary_precision")]
23use crate::number::NumberFromString;
24
25pub(crate) struct ValueVisitor;
26
27impl<'de> Visitor<'de> for ValueVisitor {
28    type Value = Value;
29
30    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
31        formatter.write_str("any valid EnCom value")
32    }
33
34    #[inline]
35    fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
36        Ok(Value::Bool(value))
37    }
38
39    #[inline]
40    fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
41        Ok(Value::Number(value.into()))
42    }
43
44    #[inline]
45    fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
46        Ok(Value::Number(value.into()))
47    }
48
49    #[inline]
50    fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
51        Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
52    }
53
54    #[cfg(any(feature = "std", feature = "alloc"))]
55    #[inline]
56    fn visit_str<E>(self, value: &str) -> Result<Value, E>
57    where
58        E: serde::de::Error,
59    {
60        self.visit_string(String::from(value))
61    }
62
63    #[cfg(any(feature = "std", feature = "alloc"))]
64    #[inline]
65    fn visit_string<E>(self, value: String) -> Result<Value, E> {
66        Ok(Value::String(value))
67    }
68
69    #[cfg(any(feature = "std", feature = "alloc"))]
70    #[inline]
71    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Value, E> {
72        Ok(Value::Bytes(v.to_owned()))
73    }
74
75    #[inline]
76    fn visit_none<E>(self) -> Result<Value, E> {
77        Ok(Value::Null)
78    }
79
80    #[inline]
81    fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
82    where
83        D: serde::Deserializer<'de>,
84    {
85        Deserialize::deserialize(deserializer)
86    }
87
88    #[inline]
89    fn visit_unit<E>(self) -> Result<Value, E> {
90        Ok(Value::Null)
91    }
92
93    #[inline]
94    fn visit_seq<A>(self, mut access: A) -> Result<Value, A::Error>
95    where
96        A: SeqAccess<'de>,
97    {
98        let mut vec = Vec::new();
99
100        if let Some(elem) = access.next_element()? {
101            match elem {
102                Value::Number(_) => {
103                    vec.push(elem);
104                    while let Some(elem) = access.next_element_seed(U64Seed)? {
105                        vec.push(elem);
106                    }
107                }
108                Value::String(_) => {
109                    vec.push(elem);
110                    while let Some(elem) = access.next_element_seed(StrSeed)? {
111                        vec.push(elem);
112                    }
113                }
114                Value::Bytes(_) => {
115                    vec.push(elem);
116                    while let Some(elem) = access.next_element_seed(BytesSeed)? {
117                        vec.push(elem);
118                    }
119                }
120                // Value::Null => seed is unknown at that point
121                // Value::Bool(_) => never gets here, because bool in EnCom is Value::Number
122                // Value::Array(_) | Value::Object(_) => goes to deserialize_any()
123                _ => {
124                    vec.push(elem);
125                    while let Some(elem) = access.next_element()? {
126                        vec.push(elem);
127                    }
128                }
129            }
130        }
131
132        Ok(Value::Array(vec))
133    }
134
135    #[cfg(any(feature = "std", feature = "alloc"))]
136    fn visit_map<A>(self, mut access: A) -> Result<Value, A::Error>
137    where
138        A: MapAccess<'de>,
139    {
140        match access.next_key_seed(KeyClassifier)? {
141            #[cfg(feature = "arbitrary_precision")]
142            Some(KeyClass::Number) => {
143                let number: NumberFromString = access.next_value()?;
144                Ok(Value::Number(number.value))
145            }
146            #[cfg(feature = "raw_value")]
147            Some(KeyClass::RawValue) => {
148                let value = access.next_value_seed(crate::raw::BoxedFromString)?;
149                crate::from_str(value.get()).map_err(de::Error::custom)
150            }
151            Some(KeyClass::Map(first_key)) => {
152                let mut values = Map::new();
153
154                values.insert(first_key, access.next_value()?);
155                while let Some((key, value)) = access.next_entry()? {
156                    values.insert(key, value);
157                }
158
159                Ok(Value::Object(values))
160            }
161            None => Ok(Value::Object(Map::new())),
162        }
163    }
164}
165
166impl<'de> Deserialize<'de> for Value {
167    #[inline]
168    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
169    where
170        D: serde::Deserializer<'de>,
171    {
172        deserializer.deserialize_any(ValueVisitor)
173    }
174}
175
176impl FromStr for Value {
177    type Err = Error;
178
179    fn from_str(s: &str) -> Result<Value, Error> {
180        crate::from_str(s)
181    }
182}
183
184macro_rules! deserialize_number {
185    ($method:ident) => {
186        #[cfg(not(feature = "arbitrary_precision"))]
187        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
188        where
189            V: Visitor<'de>,
190        {
191            match self {
192                Value::Number(n) => n.deserialize_any(visitor),
193                _ => Err(self.invalid_type(&visitor)),
194            }
195        }
196
197        #[cfg(feature = "arbitrary_precision")]
198        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
199        where
200            V: Visitor<'de>,
201        {
202            match self {
203                Value::Number(n) => n.$method(visitor),
204                _ => self.deserialize_any(visitor),
205            }
206        }
207    };
208}
209
210fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
211where
212    V: Visitor<'de>,
213{
214    let len = array.len();
215    let mut deserializer = SeqDeserializer::new(array);
216    let seq = visitor.visit_seq(&mut deserializer)?;
217    let remaining = deserializer.iter.len();
218    if remaining == 0 {
219        Ok(seq)
220    } else {
221        Err(serde::de::Error::invalid_length(
222            len,
223            &"fewer elements in array",
224        ))
225    }
226}
227
228fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error>
229where
230    V: Visitor<'de>,
231{
232    let len = object.len();
233    let mut deserializer = MapDeserializer::new(object);
234    let map = visitor.visit_map(&mut deserializer)?;
235    let remaining = deserializer.iter.len();
236    if remaining == 0 {
237        Ok(map)
238    } else {
239        Err(serde::de::Error::invalid_length(
240            len,
241            &"fewer elements in map",
242        ))
243    }
244}
245
246impl<'de> serde::Deserializer<'de> for Value {
247    type Error = Error;
248
249    #[inline]
250    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
251    where
252        V: Visitor<'de>,
253    {
254        match self {
255            Value::Null => visitor.visit_unit(),
256            Value::Bool(v) => visitor.visit_bool(v),
257            Value::Number(n) => n.deserialize_any(visitor),
258            #[cfg(any(feature = "std", feature = "alloc"))]
259            Value::String(v) => visitor.visit_string(v),
260            Value::Bytes(v) => visitor.visit_byte_buf(v),
261            Value::Array(v) => visit_array(v, visitor),
262            Value::Object(v) => visit_object(v, visitor),
263        }
264    }
265
266    deserialize_number!(deserialize_i8);
267    deserialize_number!(deserialize_i16);
268    deserialize_number!(deserialize_i32);
269    deserialize_number!(deserialize_i64);
270    deserialize_number!(deserialize_i128);
271    deserialize_number!(deserialize_u8);
272    deserialize_number!(deserialize_u16);
273    deserialize_number!(deserialize_u32);
274    deserialize_number!(deserialize_u64);
275    deserialize_number!(deserialize_u128);
276    deserialize_number!(deserialize_f32);
277    deserialize_number!(deserialize_f64);
278
279    #[inline]
280    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
281    where
282        V: Visitor<'de>,
283    {
284        match self {
285            Value::Null => visitor.visit_none(),
286            _ => visitor.visit_some(self),
287        }
288    }
289
290    #[inline]
291    fn deserialize_enum<V>(
292        self,
293        _name: &str,
294        _variants: &'static [&'static str],
295        visitor: V,
296    ) -> Result<V::Value, Error>
297    where
298        V: Visitor<'de>,
299    {
300        let (variant, value) = match self {
301            Value::Object(value) => {
302                let mut iter = value.into_iter();
303                let (variant, value) = match iter.next() {
304                    Some(v) => v,
305                    None => {
306                        return Err(serde::de::Error::invalid_value(
307                            Unexpected::Map,
308                            &"map with a single key",
309                        ));
310                    }
311                };
312                // enums are encoded in encom as maps with a single key:value pair
313                if iter.next().is_some() {
314                    return Err(serde::de::Error::invalid_value(
315                        Unexpected::Map,
316                        &"map with a single key",
317                    ));
318                }
319                (variant, Some(value))
320            }
321            Value::String(variant) => (variant, None),
322            other => {
323                return Err(serde::de::Error::invalid_type(
324                    other.unexpected(),
325                    &"string or map",
326                ));
327            }
328        };
329
330        visitor.visit_enum(EnumDeserializer { variant, value })
331    }
332
333    #[inline]
334    fn deserialize_newtype_struct<V>(
335        self,
336        name: &'static str,
337        visitor: V,
338    ) -> Result<V::Value, Error>
339    where
340        V: Visitor<'de>,
341    {
342        #[cfg(feature = "raw_value")]
343        {
344            if name == crate::raw::TOKEN {
345                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
346                    raw_value: Some(self.to_string()),
347                });
348            }
349        }
350
351        let _ = name;
352        visitor.visit_newtype_struct(self)
353    }
354
355    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
356    where
357        V: Visitor<'de>,
358    {
359        match self {
360            Value::Bool(v) => visitor.visit_bool(v),
361            _ => Err(self.invalid_type(&visitor)),
362        }
363    }
364
365    #[inline]
366    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
367    where
368        V: Visitor<'de>,
369    {
370        self.deserialize_string(visitor)
371    }
372
373    #[inline]
374    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
375    where
376        V: Visitor<'de>,
377    {
378        self.deserialize_string(visitor)
379    }
380
381    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
382    where
383        V: Visitor<'de>,
384    {
385        match self {
386            #[cfg(any(feature = "std", feature = "alloc"))]
387            Value::String(v) => visitor.visit_string(v),
388            _ => Err(self.invalid_type(&visitor)),
389        }
390    }
391
392    #[inline]
393    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
394    where
395        V: Visitor<'de>,
396    {
397        self.deserialize_byte_buf(visitor)
398    }
399
400    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
401    where
402        V: Visitor<'de>,
403    {
404        match self {
405            #[cfg(any(feature = "std", feature = "alloc"))]
406            Value::String(v) => visitor.visit_string(v),
407            Value::Array(v) => visit_array(v, visitor),
408            _ => Err(self.invalid_type(&visitor)),
409        }
410    }
411
412    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
413    where
414        V: Visitor<'de>,
415    {
416        match self {
417            Value::Null => visitor.visit_unit(),
418            _ => Err(self.invalid_type(&visitor)),
419        }
420    }
421
422    #[inline]
423    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
424    where
425        V: Visitor<'de>,
426    {
427        self.deserialize_unit(visitor)
428    }
429
430    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
431    where
432        V: Visitor<'de>,
433    {
434        match self {
435            Value::Array(v) => visit_array(v, visitor),
436            _ => Err(self.invalid_type(&visitor)),
437        }
438    }
439
440    #[inline]
441    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
442    where
443        V: Visitor<'de>,
444    {
445        self.deserialize_seq(visitor)
446    }
447
448    #[inline]
449    fn deserialize_tuple_struct<V>(
450        self,
451        _name: &'static str,
452        _len: usize,
453        visitor: V,
454    ) -> Result<V::Value, Error>
455    where
456        V: Visitor<'de>,
457    {
458        self.deserialize_seq(visitor)
459    }
460
461    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
462    where
463        V: Visitor<'de>,
464    {
465        match self {
466            Value::Object(v) => visit_object(v, visitor),
467            _ => Err(self.invalid_type(&visitor)),
468        }
469    }
470
471    fn deserialize_struct<V>(
472        self,
473        _name: &'static str,
474        _fields: &'static [&'static str],
475        visitor: V,
476    ) -> Result<V::Value, Error>
477    where
478        V: Visitor<'de>,
479    {
480        match self {
481            Value::Array(v) => visit_array(v, visitor),
482            Value::Object(v) => visit_object(v, visitor),
483            _ => Err(self.invalid_type(&visitor)),
484        }
485    }
486
487    #[inline]
488    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
489    where
490        V: Visitor<'de>,
491    {
492        self.deserialize_string(visitor)
493    }
494
495    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
496    where
497        V: Visitor<'de>,
498    {
499        drop(self);
500        visitor.visit_unit()
501    }
502}
503
504struct EnumDeserializer {
505    variant: String,
506    value: Option<Value>,
507}
508
509impl<'de> EnumAccess<'de> for EnumDeserializer {
510    type Error = Error;
511    type Variant = VariantDeserializer;
512
513    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
514    where
515        V: DeserializeSeed<'de>,
516    {
517        let variant = self.variant.into_deserializer();
518        let visitor = VariantDeserializer { value: self.value };
519        seed.deserialize(variant).map(|v| (v, visitor))
520    }
521}
522
523impl<'de> IntoDeserializer<'de, Error> for Value {
524    type Deserializer = Self;
525
526    #[inline]
527    fn into_deserializer(self) -> Self::Deserializer {
528        self
529    }
530}
531
532impl<'de> IntoDeserializer<'de, Error> for &'de Value {
533    type Deserializer = Self;
534
535    fn into_deserializer(self) -> Self::Deserializer {
536        self
537    }
538}
539
540struct VariantDeserializer {
541    value: Option<Value>,
542}
543
544impl<'de> VariantAccess<'de> for VariantDeserializer {
545    type Error = Error;
546
547    fn unit_variant(self) -> Result<(), Error> {
548        match self.value {
549            Some(value) => Deserialize::deserialize(value),
550            None => Ok(()),
551        }
552    }
553
554    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
555    where
556        T: DeserializeSeed<'de>,
557    {
558        match self.value {
559            Some(value) => seed.deserialize(value),
560            None => Err(serde::de::Error::invalid_type(
561                Unexpected::UnitVariant,
562                &"newtype variant",
563            )),
564        }
565    }
566
567    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
568    where
569        V: Visitor<'de>,
570    {
571        match self.value {
572            Some(Value::Array(v)) => {
573                if v.is_empty() {
574                    visitor.visit_unit()
575                } else {
576                    visit_array(v, visitor)
577                }
578            }
579            Some(other) => Err(serde::de::Error::invalid_type(
580                other.unexpected(),
581                &"tuple variant",
582            )),
583            None => Err(serde::de::Error::invalid_type(
584                Unexpected::UnitVariant,
585                &"tuple variant",
586            )),
587        }
588    }
589
590    fn struct_variant<V>(
591        self,
592        _fields: &'static [&'static str],
593        visitor: V,
594    ) -> Result<V::Value, Error>
595    where
596        V: Visitor<'de>,
597    {
598        match self.value {
599            Some(Value::Object(v)) => visit_object(v, visitor),
600            Some(other) => Err(serde::de::Error::invalid_type(
601                other.unexpected(),
602                &"struct variant",
603            )),
604            None => Err(serde::de::Error::invalid_type(
605                Unexpected::UnitVariant,
606                &"struct variant",
607            )),
608        }
609    }
610}
611
612struct SeqDeserializer {
613    iter: vec::IntoIter<Value>,
614}
615
616impl SeqDeserializer {
617    fn new(vec: Vec<Value>) -> Self {
618        SeqDeserializer {
619            iter: vec.into_iter(),
620        }
621    }
622}
623
624impl<'de> SeqAccess<'de> for SeqDeserializer {
625    type Error = Error;
626
627    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
628    where
629        T: DeserializeSeed<'de>,
630    {
631        match self.iter.next() {
632            Some(value) => seed.deserialize(value).map(Some),
633            None => Ok(None),
634        }
635    }
636
637    fn size_hint(&self) -> Option<usize> {
638        match self.iter.size_hint() {
639            (lower, Some(upper)) if lower == upper => Some(upper),
640            _ => None,
641        }
642    }
643}
644
645struct MapDeserializer {
646    iter: <Map<String, Value> as IntoIterator>::IntoIter,
647    value: Option<Value>,
648}
649
650impl MapDeserializer {
651    fn new(map: Map<String, Value>) -> Self {
652        MapDeserializer {
653            iter: map.into_iter(),
654            value: None,
655        }
656    }
657}
658
659impl<'de> MapAccess<'de> for MapDeserializer {
660    type Error = Error;
661
662    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
663    where
664        T: DeserializeSeed<'de>,
665    {
666        match self.iter.next() {
667            Some((key, value)) => {
668                self.value = Some(value);
669                let key_de = MapKeyDeserializer {
670                    key: Cow::Owned(key),
671                };
672                seed.deserialize(key_de).map(Some)
673            }
674            None => Ok(None),
675        }
676    }
677
678    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
679    where
680        T: DeserializeSeed<'de>,
681    {
682        match self.value.take() {
683            Some(value) => seed.deserialize(value),
684            None => Err(serde::de::Error::custom("value is missing")),
685        }
686    }
687
688    fn size_hint(&self) -> Option<usize> {
689        match self.iter.size_hint() {
690            (lower, Some(upper)) if lower == upper => Some(upper),
691            _ => None,
692        }
693    }
694}
695
696macro_rules! deserialize_value_ref_number {
697    ($method:ident) => {
698        #[cfg(not(feature = "arbitrary_precision"))]
699        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
700        where
701            V: Visitor<'de>,
702        {
703            match self {
704                Value::Number(n) => n.deserialize_any(visitor),
705                _ => Err(self.invalid_type(&visitor)),
706            }
707        }
708
709        #[cfg(feature = "arbitrary_precision")]
710        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
711        where
712            V: Visitor<'de>,
713        {
714            match self {
715                Value::Number(n) => n.$method(visitor),
716                _ => self.deserialize_any(visitor),
717            }
718        }
719    };
720}
721
722fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
723where
724    V: Visitor<'de>,
725{
726    let len = array.len();
727    let mut deserializer = SeqRefDeserializer::new(array);
728    let seq = visitor.visit_seq(&mut deserializer)?;
729    let remaining = deserializer.iter.len();
730    if remaining == 0 {
731        Ok(seq)
732    } else {
733        Err(serde::de::Error::invalid_length(
734            len,
735            &"fewer elements in array",
736        ))
737    }
738}
739
740fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error>
741where
742    V: Visitor<'de>,
743{
744    let len = object.len();
745    let mut deserializer = MapRefDeserializer::new(object);
746    let map = visitor.visit_map(&mut deserializer)?;
747    let remaining = deserializer.iter.len();
748    if remaining == 0 {
749        Ok(map)
750    } else {
751        Err(serde::de::Error::invalid_length(
752            len,
753            &"fewer elements in map",
754        ))
755    }
756}
757
758impl<'de> serde::Deserializer<'de> for &'de Value {
759    type Error = Error;
760
761    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
762    where
763        V: Visitor<'de>,
764    {
765        match self {
766            Value::Null => visitor.visit_unit(),
767            Value::Bool(v) => visitor.visit_bool(*v),
768            Value::Number(n) => n.deserialize_any(visitor),
769            Value::String(v) => visitor.visit_borrowed_str(v),
770            Value::Bytes(v) => visitor.visit_borrowed_bytes(v),
771            Value::Array(v) => visit_array_ref(v, visitor),
772            Value::Object(v) => visit_object_ref(v, visitor),
773        }
774    }
775
776    deserialize_value_ref_number!(deserialize_i8);
777    deserialize_value_ref_number!(deserialize_i16);
778    deserialize_value_ref_number!(deserialize_i32);
779    deserialize_value_ref_number!(deserialize_i64);
780    deserialize_number!(deserialize_i128);
781    deserialize_value_ref_number!(deserialize_u8);
782    deserialize_value_ref_number!(deserialize_u16);
783    deserialize_value_ref_number!(deserialize_u32);
784    deserialize_value_ref_number!(deserialize_u64);
785    deserialize_number!(deserialize_u128);
786    deserialize_value_ref_number!(deserialize_f32);
787    deserialize_value_ref_number!(deserialize_f64);
788
789    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
790    where
791        V: Visitor<'de>,
792    {
793        match *self {
794            Value::Null => visitor.visit_none(),
795            _ => visitor.visit_some(self),
796        }
797    }
798
799    fn deserialize_enum<V>(
800        self,
801        _name: &str,
802        _variants: &'static [&'static str],
803        visitor: V,
804    ) -> Result<V::Value, Error>
805    where
806        V: Visitor<'de>,
807    {
808        let (variant, value) = match self {
809            Value::Object(value) => {
810                let mut iter = value.into_iter();
811                let (variant, value) = match iter.next() {
812                    Some(v) => v,
813                    None => {
814                        return Err(serde::de::Error::invalid_value(
815                            Unexpected::Map,
816                            &"map with a single key",
817                        ));
818                    }
819                };
820                // enums are encoded in encom as maps with a single key:value pair
821                if iter.next().is_some() {
822                    return Err(serde::de::Error::invalid_value(
823                        Unexpected::Map,
824                        &"map with a single key",
825                    ));
826                }
827                (variant, Some(value))
828            }
829            Value::String(variant) => (variant, None),
830            other => {
831                return Err(serde::de::Error::invalid_type(
832                    other.unexpected(),
833                    &"string or map",
834                ));
835            }
836        };
837
838        visitor.visit_enum(EnumRefDeserializer { variant, value })
839    }
840
841    #[inline]
842    fn deserialize_newtype_struct<V>(
843        self,
844        name: &'static str,
845        visitor: V,
846    ) -> Result<V::Value, Error>
847    where
848        V: Visitor<'de>,
849    {
850        #[cfg(feature = "raw_value")]
851        {
852            if name == crate::raw::TOKEN {
853                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
854                    raw_value: Some(self.to_string()),
855                });
856            }
857        }
858
859        let _ = name;
860        visitor.visit_newtype_struct(self)
861    }
862
863    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
864    where
865        V: Visitor<'de>,
866    {
867        match *self {
868            Value::Bool(v) => visitor.visit_bool(v),
869            _ => Err(self.invalid_type(&visitor)),
870        }
871    }
872
873    #[inline]
874    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
875    where
876        V: Visitor<'de>,
877    {
878        self.deserialize_str(visitor)
879    }
880
881    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
882    where
883        V: Visitor<'de>,
884    {
885        match self {
886            Value::String(v) => visitor.visit_borrowed_str(v),
887            _ => Err(self.invalid_type(&visitor)),
888        }
889    }
890
891    #[inline]
892    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
893    where
894        V: Visitor<'de>,
895    {
896        self.deserialize_str(visitor)
897    }
898
899    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
900    where
901        V: Visitor<'de>,
902    {
903        match self {
904            Value::String(v) => visitor.visit_borrowed_str(v),
905            Value::Array(v) => visit_array_ref(v, visitor),
906            _ => Err(self.invalid_type(&visitor)),
907        }
908    }
909
910    #[inline]
911    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
912    where
913        V: Visitor<'de>,
914    {
915        self.deserialize_bytes(visitor)
916    }
917
918    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
919    where
920        V: Visitor<'de>,
921    {
922        match *self {
923            Value::Null => visitor.visit_unit(),
924            _ => Err(self.invalid_type(&visitor)),
925        }
926    }
927
928    #[inline]
929    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
930    where
931        V: Visitor<'de>,
932    {
933        self.deserialize_unit(visitor)
934    }
935
936    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
937    where
938        V: Visitor<'de>,
939    {
940        match self {
941            Value::Array(v) => visit_array_ref(v, visitor),
942            _ => Err(self.invalid_type(&visitor)),
943        }
944    }
945
946    #[inline]
947    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
948    where
949        V: Visitor<'de>,
950    {
951        self.deserialize_seq(visitor)
952    }
953
954    #[inline]
955    fn deserialize_tuple_struct<V>(
956        self,
957        _name: &'static str,
958        _len: usize,
959        visitor: V,
960    ) -> Result<V::Value, Error>
961    where
962        V: Visitor<'de>,
963    {
964        self.deserialize_seq(visitor)
965    }
966
967    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
968    where
969        V: Visitor<'de>,
970    {
971        match self {
972            Value::Object(v) => visit_object_ref(v, visitor),
973            _ => Err(self.invalid_type(&visitor)),
974        }
975    }
976
977    fn deserialize_struct<V>(
978        self,
979        _name: &'static str,
980        _fields: &'static [&'static str],
981        visitor: V,
982    ) -> Result<V::Value, Error>
983    where
984        V: Visitor<'de>,
985    {
986        match self {
987            Value::Array(v) => visit_array_ref(v, visitor),
988            Value::Object(v) => visit_object_ref(v, visitor),
989            _ => Err(self.invalid_type(&visitor)),
990        }
991    }
992
993    #[inline]
994    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
995    where
996        V: Visitor<'de>,
997    {
998        self.deserialize_str(visitor)
999    }
1000
1001    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1002    where
1003        V: Visitor<'de>,
1004    {
1005        visitor.visit_unit()
1006    }
1007}
1008
1009struct EnumRefDeserializer<'de> {
1010    variant: &'de str,
1011    value: Option<&'de Value>,
1012}
1013
1014impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
1015    type Error = Error;
1016    type Variant = VariantRefDeserializer<'de>;
1017
1018    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
1019    where
1020        V: DeserializeSeed<'de>,
1021    {
1022        let variant = self.variant.into_deserializer();
1023        let visitor = VariantRefDeserializer { value: self.value };
1024        seed.deserialize(variant).map(|v| (v, visitor))
1025    }
1026}
1027
1028struct VariantRefDeserializer<'de> {
1029    value: Option<&'de Value>,
1030}
1031
1032impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
1033    type Error = Error;
1034
1035    fn unit_variant(self) -> Result<(), Error> {
1036        match self.value {
1037            Some(value) => Deserialize::deserialize(value),
1038            None => Ok(()),
1039        }
1040    }
1041
1042    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1043    where
1044        T: DeserializeSeed<'de>,
1045    {
1046        match self.value {
1047            Some(value) => seed.deserialize(value),
1048            None => Err(serde::de::Error::invalid_type(
1049                Unexpected::UnitVariant,
1050                &"newtype variant",
1051            )),
1052        }
1053    }
1054
1055    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1056    where
1057        V: Visitor<'de>,
1058    {
1059        match self.value {
1060            Some(Value::Array(v)) => {
1061                if v.is_empty() {
1062                    visitor.visit_unit()
1063                } else {
1064                    visit_array_ref(v, visitor)
1065                }
1066            }
1067            Some(other) => Err(serde::de::Error::invalid_type(
1068                other.unexpected(),
1069                &"tuple variant",
1070            )),
1071            None => Err(serde::de::Error::invalid_type(
1072                Unexpected::UnitVariant,
1073                &"tuple variant",
1074            )),
1075        }
1076    }
1077
1078    fn struct_variant<V>(
1079        self,
1080        _fields: &'static [&'static str],
1081        visitor: V,
1082    ) -> Result<V::Value, Error>
1083    where
1084        V: Visitor<'de>,
1085    {
1086        match self.value {
1087            Some(Value::Object(v)) => visit_object_ref(v, visitor),
1088            Some(other) => Err(serde::de::Error::invalid_type(
1089                other.unexpected(),
1090                &"struct variant",
1091            )),
1092            None => Err(serde::de::Error::invalid_type(
1093                Unexpected::UnitVariant,
1094                &"struct variant",
1095            )),
1096        }
1097    }
1098}
1099
1100struct SeqRefDeserializer<'de> {
1101    iter: slice::Iter<'de, Value>,
1102}
1103
1104impl<'de> SeqRefDeserializer<'de> {
1105    fn new(slice: &'de [Value]) -> Self {
1106        SeqRefDeserializer { iter: slice.iter() }
1107    }
1108}
1109
1110impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
1111    type Error = Error;
1112
1113    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1114    where
1115        T: DeserializeSeed<'de>,
1116    {
1117        match self.iter.next() {
1118            Some(value) => seed.deserialize(value).map(Some),
1119            None => Ok(None),
1120        }
1121    }
1122
1123    fn size_hint(&self) -> Option<usize> {
1124        match self.iter.size_hint() {
1125            (lower, Some(upper)) if lower == upper => Some(upper),
1126            _ => None,
1127        }
1128    }
1129}
1130
1131struct MapRefDeserializer<'de> {
1132    iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
1133    value: Option<&'de Value>,
1134}
1135
1136impl<'de> MapRefDeserializer<'de> {
1137    fn new(map: &'de Map<String, Value>) -> Self {
1138        MapRefDeserializer {
1139            iter: map.into_iter(),
1140            value: None,
1141        }
1142    }
1143}
1144
1145impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
1146    type Error = Error;
1147
1148    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1149    where
1150        T: DeserializeSeed<'de>,
1151    {
1152        match self.iter.next() {
1153            Some((key, value)) => {
1154                self.value = Some(value);
1155                let key_de = MapKeyDeserializer {
1156                    key: Cow::Borrowed(&**key),
1157                };
1158                seed.deserialize(key_de).map(Some)
1159            }
1160            None => Ok(None),
1161        }
1162    }
1163
1164    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1165    where
1166        T: DeserializeSeed<'de>,
1167    {
1168        match self.value.take() {
1169            Some(value) => seed.deserialize(value),
1170            None => Err(serde::de::Error::custom("value is missing")),
1171        }
1172    }
1173
1174    fn size_hint(&self) -> Option<usize> {
1175        match self.iter.size_hint() {
1176            (lower, Some(upper)) if lower == upper => Some(upper),
1177            _ => None,
1178        }
1179    }
1180}
1181
1182struct MapKeyDeserializer<'de> {
1183    key: Cow<'de, str>,
1184}
1185
1186macro_rules! deserialize_numeric_key {
1187    ($method:ident) => {
1188        deserialize_numeric_key!($method, deserialize_number);
1189    };
1190
1191    ($method:ident, $using:ident) => {
1192        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
1193        where
1194            V: Visitor<'de>,
1195        {
1196            let mut de = crate::Deserializer::from_str(&self.key);
1197
1198            match de.peek()? {
1199                Some(b'0'..=b'9' | b'-') => {}
1200                _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)),
1201            }
1202
1203            let number = de.$using(visitor)?;
1204
1205            if de.peek()?.is_some() {
1206                return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0));
1207            }
1208
1209            Ok(number)
1210        }
1211    };
1212}
1213
1214impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
1215    type Error = Error;
1216
1217    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1218    where
1219        V: Visitor<'de>,
1220    {
1221        BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
1222    }
1223
1224    deserialize_numeric_key!(deserialize_i8);
1225    deserialize_numeric_key!(deserialize_i16);
1226    deserialize_numeric_key!(deserialize_i32);
1227    deserialize_numeric_key!(deserialize_i64);
1228    deserialize_numeric_key!(deserialize_u8);
1229    deserialize_numeric_key!(deserialize_u16);
1230    deserialize_numeric_key!(deserialize_u32);
1231    deserialize_numeric_key!(deserialize_u64);
1232    #[cfg(not(feature = "float_roundtrip"))]
1233    deserialize_numeric_key!(deserialize_f32);
1234    deserialize_numeric_key!(deserialize_f64);
1235
1236    #[cfg(feature = "float_roundtrip")]
1237    deserialize_numeric_key!(deserialize_f32, do_deserialize_f32);
1238    deserialize_numeric_key!(deserialize_i128, do_deserialize_i128);
1239    deserialize_numeric_key!(deserialize_u128, do_deserialize_u128);
1240
1241    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
1242    where
1243        V: Visitor<'de>,
1244    {
1245        // match self.key.as_ref() ???
1246        if self.key == "t" {
1247            visitor.visit_bool(true)
1248        } else if self.key == "f" {
1249            visitor.visit_bool(false)
1250        } else {
1251            Err(serde::de::Error::invalid_type(
1252                Unexpected::Str(&self.key),
1253                &visitor,
1254            ))
1255        }
1256    }
1257
1258    #[inline]
1259    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
1260    where
1261        V: Visitor<'de>,
1262    {
1263        // Map keys cannot be null.
1264        visitor.visit_some(self)
1265    }
1266
1267    #[inline]
1268    fn deserialize_newtype_struct<V>(
1269        self,
1270        _name: &'static str,
1271        visitor: V,
1272    ) -> Result<V::Value, Error>
1273    where
1274        V: Visitor<'de>,
1275    {
1276        visitor.visit_newtype_struct(self)
1277    }
1278
1279    fn deserialize_enum<V>(
1280        self,
1281        name: &'static str,
1282        variants: &'static [&'static str],
1283        visitor: V,
1284    ) -> Result<V::Value, Error>
1285    where
1286        V: Visitor<'de>,
1287    {
1288        self.key
1289            .into_deserializer()
1290            .deserialize_enum(name, variants, visitor)
1291    }
1292
1293    forward_to_deserialize_any! {
1294        char str string bytes byte_buf unit unit_struct seq tuple
1295        tuple_struct map struct identifier ignored_any
1296    }
1297}
1298
1299struct KeyClassifier;
1300
1301enum KeyClass {
1302    Map(String),
1303    #[cfg(feature = "arbitrary_precision")]
1304    Number,
1305    #[cfg(feature = "raw_value")]
1306    RawValue,
1307}
1308
1309impl<'de> DeserializeSeed<'de> for KeyClassifier {
1310    type Value = KeyClass;
1311
1312    #[inline]
1313    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1314    where
1315        D: serde::Deserializer<'de>,
1316    {
1317        deserializer.deserialize_str(self)
1318    }
1319}
1320
1321impl<'de> Visitor<'de> for KeyClassifier {
1322    type Value = KeyClass;
1323
1324    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1325        formatter.write_str("a string key")
1326    }
1327
1328    #[inline]
1329    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1330    where
1331        E: de::Error,
1332    {
1333        match s {
1334            #[cfg(feature = "arbitrary_precision")]
1335            crate::number::TOKEN => Ok(KeyClass::Number),
1336            #[cfg(feature = "raw_value")]
1337            crate::raw::TOKEN => Ok(KeyClass::RawValue),
1338            _ => Ok(KeyClass::Map(s.to_owned())),
1339        }
1340    }
1341
1342    #[cfg(any(feature = "std", feature = "alloc"))]
1343    #[inline]
1344    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
1345    where
1346        E: de::Error,
1347    {
1348        match s.as_str() {
1349            #[cfg(feature = "arbitrary_precision")]
1350            crate::number::TOKEN => Ok(KeyClass::Number),
1351            #[cfg(feature = "raw_value")]
1352            crate::raw::TOKEN => Ok(KeyClass::RawValue),
1353            _ => Ok(KeyClass::Map(s)),
1354        }
1355    }
1356}
1357
1358impl Value {
1359    #[cold]
1360    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
1361    where
1362        E: serde::de::Error,
1363    {
1364        serde::de::Error::invalid_type(self.unexpected(), exp)
1365    }
1366
1367    #[cold]
1368    fn unexpected(&self) -> Unexpected {
1369        match self {
1370            Value::Null => Unexpected::Unit,
1371            Value::Bool(b) => Unexpected::Bool(*b),
1372            Value::Number(n) => n.unexpected(),
1373            Value::String(s) => Unexpected::Str(s),
1374            Value::Bytes(s) => Unexpected::Bytes(s),
1375            Value::Array(_) => Unexpected::Seq,
1376            Value::Object(_) => Unexpected::Map,
1377        }
1378    }
1379}
1380
1381struct BorrowedCowStrDeserializer<'de> {
1382    value: Cow<'de, str>,
1383}
1384
1385impl<'de> BorrowedCowStrDeserializer<'de> {
1386    fn new(value: Cow<'de, str>) -> Self {
1387        BorrowedCowStrDeserializer { value }
1388    }
1389}
1390
1391impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
1392    type Error = Error;
1393
1394    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1395    where
1396        V: de::Visitor<'de>,
1397    {
1398        match self.value {
1399            Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
1400            #[cfg(any(feature = "std", feature = "alloc"))]
1401            Cow::Owned(string) => visitor.visit_string(string),
1402        }
1403    }
1404
1405    fn deserialize_enum<V>(
1406        self,
1407        _name: &str,
1408        _variants: &'static [&'static str],
1409        visitor: V,
1410    ) -> Result<V::Value, Error>
1411    where
1412        V: de::Visitor<'de>,
1413    {
1414        visitor.visit_enum(self)
1415    }
1416
1417    forward_to_deserialize_any! {
1418        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1419        bytes byte_buf option unit unit_struct newtype_struct seq tuple
1420        tuple_struct map struct identifier ignored_any
1421    }
1422}
1423
1424impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
1425    type Error = Error;
1426    type Variant = UnitOnly;
1427
1428    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error>
1429    where
1430        T: de::DeserializeSeed<'de>,
1431    {
1432        let value = seed.deserialize(self)?;
1433        Ok((value, UnitOnly))
1434    }
1435}
1436
1437struct UnitOnly;
1438
1439impl<'de> de::VariantAccess<'de> for UnitOnly {
1440    type Error = Error;
1441
1442    #[inline]
1443    fn unit_variant(self) -> Result<(), Error> {
1444        Ok(())
1445    }
1446
1447    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
1448    where
1449        T: de::DeserializeSeed<'de>,
1450    {
1451        Err(de::Error::invalid_type(
1452            Unexpected::UnitVariant,
1453            &"newtype variant",
1454        ))
1455    }
1456
1457    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
1458    where
1459        V: de::Visitor<'de>,
1460    {
1461        Err(de::Error::invalid_type(
1462            Unexpected::UnitVariant,
1463            &"tuple variant",
1464        ))
1465    }
1466
1467    fn struct_variant<V>(
1468        self,
1469        _fields: &'static [&'static str],
1470        _visitor: V,
1471    ) -> Result<V::Value, Error>
1472    where
1473        V: de::Visitor<'de>,
1474    {
1475        Err(de::Error::invalid_type(
1476            Unexpected::UnitVariant,
1477            &"struct variant",
1478        ))
1479    }
1480}
serde_encom/value/des.rs

serde_encom/value/
des.rs
