serde_yaml/value/
de.rs

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

serde_yaml/value/
de.rs
