pochoir_lang/value/
deserializer.rs

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

pochoir_lang/value/
deserializer.rs
