serde_yaml/value/
de.rs

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

serde_yaml/value/
de.rs
