serde_yaml/value/
de.rs

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

serde_yaml/value/
de.rs
