serde_yaml/
with.rs

1//! Customizations to use with Serde's `#[serde(with = …)]` attribute.
2
3/// Serialize/deserialize an enum using a YAML map containing one entry in which
4/// the key identifies the variant name.
5///
6/// # Example
7///
8/// ```
9/// # use serde_derive::{Deserialize, Serialize};
10/// use serde::{Deserialize, Serialize};
11///
12/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
13/// enum Enum {
14///     Unit,
15///     Newtype(usize),
16///     Tuple(usize, usize),
17///     Struct { value: usize },
18/// }
19///
20/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
21/// struct Struct {
22///     #[serde(with = "serde_yaml::with::singleton_map")]
23///     w: Enum,
24///     #[serde(with = "serde_yaml::with::singleton_map")]
25///     x: Enum,
26///     #[serde(with = "serde_yaml::with::singleton_map")]
27///     y: Enum,
28///     #[serde(with = "serde_yaml::with::singleton_map")]
29///     z: Enum,
30/// }
31///
32/// fn main() {
33///     let object = Struct {
34///         w: Enum::Unit,
35///         x: Enum::Newtype(1),
36///         y: Enum::Tuple(1, 1),
37///         z: Enum::Struct { value: 1 },
38///     };
39///
40///     let yaml = serde_yaml::to_string(&object).unwrap();
41///     print!("{}", yaml);
42///
43///     let deserialized: Struct = serde_yaml::from_str(&yaml).unwrap();
44///     assert_eq!(object, deserialized);
45/// }
46/// ```
47///
48/// The representation using `singleton_map` on all the fields is:
49///
50/// ```yaml
51/// w: Unit
52/// x:
53///   Newtype: 1
54/// y:
55///   Tuple:
56///   - 1
57///   - 1
58/// z:
59///   Struct:
60///     value: 1
61/// ```
62///
63/// Without `singleton_map`, the default behavior would have been to serialize
64/// as:
65///
66/// ```yaml
67/// w: Unit
68/// x: !Newtype 1
69/// y: !Tuple
70/// - 1
71/// - 1
72/// z: !Struct
73///   value: 1
74/// ```
75pub mod singleton_map {
76    use std::fmt::{self, Display};
77
78    use serde::{
79        de::{
80            self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, IgnoredAny, MapAccess, Unexpected,
81            VariantAccess, Visitor,
82        },
83        ser::{self, Serialize, SerializeMap, SerializeStructVariant, SerializeTupleVariant, Serializer},
84    };
85
86    use crate::value::{Mapping, Sequence, Value};
87
88    #[allow(missing_docs)]
89    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
90    where
91        T: Serialize,
92        S: Serializer,
93    {
94        value.serialize(SingletonMap {
95            delegate: serializer,
96        })
97    }
98
99    #[allow(missing_docs)]
100    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
101    where
102        T: Deserialize<'de>,
103        D: Deserializer<'de>,
104    {
105        T::deserialize(SingletonMap {
106            delegate: deserializer,
107        })
108    }
109
110    struct SingletonMap<D> {
111        delegate: D,
112    }
113
114    impl<D> Serialize for SingletonMap<D>
115    where
116        D: Serialize,
117    {
118        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
119        where
120            S: Serializer,
121        {
122            self.delegate.serialize(SingletonMap {
123                delegate: serializer,
124            })
125        }
126    }
127
128    impl<D> Serializer for SingletonMap<D>
129    where
130        D: Serializer,
131    {
132        type Ok = D::Ok;
133        type Error = D::Error;
134
135        type SerializeSeq = D::SerializeSeq;
136        type SerializeTuple = D::SerializeTuple;
137        type SerializeTupleStruct = D::SerializeTupleStruct;
138        type SerializeTupleVariant = SerializeTupleVariantAsSingletonMap<D::SerializeMap>;
139        type SerializeMap = D::SerializeMap;
140        type SerializeStruct = D::SerializeStruct;
141        type SerializeStructVariant = SerializeStructVariantAsSingletonMap<D::SerializeMap>;
142
143        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
144            self.delegate.serialize_bool(v)
145        }
146
147        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
148            self.delegate.serialize_i8(v)
149        }
150
151        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
152            self.delegate.serialize_i16(v)
153        }
154
155        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
156            self.delegate.serialize_i32(v)
157        }
158
159        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
160            self.delegate.serialize_i64(v)
161        }
162
163        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
164            self.delegate.serialize_i128(v)
165        }
166
167        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
168            self.delegate.serialize_u8(v)
169        }
170
171        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
172            self.delegate.serialize_u16(v)
173        }
174
175        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
176            self.delegate.serialize_u32(v)
177        }
178
179        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
180            self.delegate.serialize_u64(v)
181        }
182
183        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
184            self.delegate.serialize_u128(v)
185        }
186
187        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
188            self.delegate.serialize_f32(v)
189        }
190
191        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
192            self.delegate.serialize_f64(v)
193        }
194
195        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
196            self.delegate.serialize_char(v)
197        }
198
199        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
200            self.delegate.serialize_str(v)
201        }
202
203        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
204            self.delegate.serialize_bytes(v)
205        }
206
207        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
208            self.delegate.serialize_unit()
209        }
210
211        fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
212            self.delegate.serialize_unit_struct(name)
213        }
214
215        fn serialize_unit_variant(
216            self,
217            name: &'static str,
218            variant_index: u32,
219            variant: &'static str,
220        ) -> Result<Self::Ok, Self::Error> {
221            self.delegate.serialize_unit_variant(name, variant_index, variant)
222        }
223
224        fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
225        where
226            T: ?Sized + Serialize,
227        {
228            self.delegate.serialize_newtype_struct(name, value)
229        }
230
231        fn serialize_newtype_variant<T>(
232            self,
233            _name: &'static str,
234            _variant_index: u32,
235            variant: &'static str,
236            value: &T,
237        ) -> Result<Self::Ok, Self::Error>
238        where
239            T: ?Sized + Serialize,
240        {
241            let mut map = self.delegate.serialize_map(Some(1))?;
242            map.serialize_entry(variant, value)?;
243            map.end()
244        }
245
246        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
247            self.delegate.serialize_none()
248        }
249
250        fn serialize_some<V>(self, value: &V) -> Result<Self::Ok, Self::Error>
251        where
252            V: ?Sized + Serialize,
253        {
254            self.delegate.serialize_some(&SingletonMap {
255                delegate: value,
256            })
257        }
258
259        fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
260            self.delegate.serialize_seq(len)
261        }
262
263        fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
264            self.delegate.serialize_tuple(len)
265        }
266
267        fn serialize_tuple_struct(
268            self,
269            name: &'static str,
270            len: usize,
271        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
272            self.delegate.serialize_tuple_struct(name, len)
273        }
274
275        fn serialize_tuple_variant(
276            self,
277            _name: &'static str,
278            _variant_index: u32,
279            variant: &'static str,
280            len: usize,
281        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
282            let mut map = self.delegate.serialize_map(Some(1))?;
283            map.serialize_key(variant)?;
284            let sequence = Sequence::with_capacity(len);
285            Ok(SerializeTupleVariantAsSingletonMap {
286                map,
287                sequence,
288            })
289        }
290
291        fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
292            self.delegate.serialize_map(len)
293        }
294
295        fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
296            self.delegate.serialize_struct(name, len)
297        }
298
299        fn serialize_struct_variant(
300            self,
301            _name: &'static str,
302            _variant_index: u32,
303            variant: &'static str,
304            len: usize,
305        ) -> Result<Self::SerializeStructVariant, Self::Error> {
306            let mut map = self.delegate.serialize_map(Some(1))?;
307            map.serialize_key(variant)?;
308            let mapping = Mapping::with_capacity(len);
309            Ok(SerializeStructVariantAsSingletonMap {
310                map,
311                mapping,
312            })
313        }
314
315        fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
316        where
317            T: ?Sized + Display,
318        {
319            self.delegate.collect_str(value)
320        }
321
322        fn is_human_readable(&self) -> bool {
323            self.delegate.is_human_readable()
324        }
325    }
326
327    struct SerializeTupleVariantAsSingletonMap<M> {
328        map: M,
329        sequence: Sequence,
330    }
331
332    impl<M> SerializeTupleVariant for SerializeTupleVariantAsSingletonMap<M>
333    where
334        M: SerializeMap,
335    {
336        type Ok = M::Ok;
337        type Error = M::Error;
338
339        fn serialize_field<T>(&mut self, field: &T) -> Result<(), Self::Error>
340        where
341            T: ?Sized + Serialize,
342        {
343            let value = field.serialize(crate::value::Serializer).map_err(ser::Error::custom)?;
344            self.sequence.push(value);
345            Ok(())
346        }
347
348        fn end(mut self) -> Result<Self::Ok, Self::Error> {
349            self.map.serialize_value(&self.sequence)?;
350            self.map.end()
351        }
352    }
353
354    struct SerializeStructVariantAsSingletonMap<M> {
355        map: M,
356        mapping: Mapping,
357    }
358
359    impl<M> SerializeStructVariant for SerializeStructVariantAsSingletonMap<M>
360    where
361        M: SerializeMap,
362    {
363        type Ok = M::Ok;
364        type Error = M::Error;
365
366        fn serialize_field<T>(&mut self, name: &'static str, field: &T) -> Result<(), Self::Error>
367        where
368            T: ?Sized + Serialize,
369        {
370            let value = field.serialize(crate::value::Serializer).map_err(ser::Error::custom)?;
371            self.mapping.insert(Value::String(name.to_owned()), value);
372            Ok(())
373        }
374
375        fn end(mut self) -> Result<Self::Ok, Self::Error> {
376            self.map.serialize_value(&self.mapping)?;
377            self.map.end()
378        }
379    }
380
381    impl<'de, D> Deserializer<'de> for SingletonMap<D>
382    where
383        D: Deserializer<'de>,
384    {
385        type Error = D::Error;
386
387        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
388        where
389            V: Visitor<'de>,
390        {
391            self.delegate.deserialize_any(visitor)
392        }
393
394        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
395        where
396            V: Visitor<'de>,
397        {
398            self.delegate.deserialize_bool(visitor)
399        }
400
401        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
402        where
403            V: Visitor<'de>,
404        {
405            self.delegate.deserialize_i8(visitor)
406        }
407
408        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
409        where
410            V: Visitor<'de>,
411        {
412            self.delegate.deserialize_i16(visitor)
413        }
414
415        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
416        where
417            V: Visitor<'de>,
418        {
419            self.delegate.deserialize_i32(visitor)
420        }
421
422        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
423        where
424            V: Visitor<'de>,
425        {
426            self.delegate.deserialize_i64(visitor)
427        }
428
429        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
430        where
431            V: Visitor<'de>,
432        {
433            self.delegate.deserialize_i128(visitor)
434        }
435
436        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
437        where
438            V: Visitor<'de>,
439        {
440            self.delegate.deserialize_u8(visitor)
441        }
442
443        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
444        where
445            V: Visitor<'de>,
446        {
447            self.delegate.deserialize_u16(visitor)
448        }
449
450        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
451        where
452            V: Visitor<'de>,
453        {
454            self.delegate.deserialize_u32(visitor)
455        }
456
457        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
458        where
459            V: Visitor<'de>,
460        {
461            self.delegate.deserialize_u64(visitor)
462        }
463
464        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
465        where
466            V: Visitor<'de>,
467        {
468            self.delegate.deserialize_u128(visitor)
469        }
470
471        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
472        where
473            V: Visitor<'de>,
474        {
475            self.delegate.deserialize_f32(visitor)
476        }
477
478        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
479        where
480            V: Visitor<'de>,
481        {
482            self.delegate.deserialize_f64(visitor)
483        }
484
485        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
486        where
487            V: Visitor<'de>,
488        {
489            self.delegate.deserialize_char(visitor)
490        }
491
492        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
493        where
494            V: Visitor<'de>,
495        {
496            self.delegate.deserialize_str(visitor)
497        }
498
499        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
500        where
501            V: Visitor<'de>,
502        {
503            self.delegate.deserialize_string(visitor)
504        }
505
506        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
507        where
508            V: Visitor<'de>,
509        {
510            self.delegate.deserialize_bytes(visitor)
511        }
512
513        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
514        where
515            V: Visitor<'de>,
516        {
517            self.delegate.deserialize_byte_buf(visitor)
518        }
519
520        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
521        where
522            V: Visitor<'de>,
523        {
524            self.delegate.deserialize_option(SingletonMapAsEnum {
525                name: "",
526                delegate: visitor,
527            })
528        }
529
530        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
531        where
532            V: Visitor<'de>,
533        {
534            self.delegate.deserialize_unit(visitor)
535        }
536
537        fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
538        where
539            V: Visitor<'de>,
540        {
541            self.delegate.deserialize_unit_struct(name, visitor)
542        }
543
544        fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
545        where
546            V: Visitor<'de>,
547        {
548            self.delegate.deserialize_newtype_struct(name, visitor)
549        }
550
551        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
552        where
553            V: Visitor<'de>,
554        {
555            self.delegate.deserialize_seq(visitor)
556        }
557
558        fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
559        where
560            V: Visitor<'de>,
561        {
562            self.delegate.deserialize_tuple(len, visitor)
563        }
564
565        fn deserialize_tuple_struct<V>(
566            self,
567            name: &'static str,
568            len: usize,
569            visitor: V,
570        ) -> Result<V::Value, Self::Error>
571        where
572            V: Visitor<'de>,
573        {
574            self.delegate.deserialize_tuple_struct(name, len, visitor)
575        }
576
577        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
578        where
579            V: Visitor<'de>,
580        {
581            self.delegate.deserialize_map(visitor)
582        }
583
584        fn deserialize_struct<V>(
585            self,
586            name: &'static str,
587            fields: &'static [&'static str],
588            visitor: V,
589        ) -> Result<V::Value, Self::Error>
590        where
591            V: Visitor<'de>,
592        {
593            self.delegate.deserialize_struct(name, fields, visitor)
594        }
595
596        fn deserialize_enum<V>(
597            self,
598            name: &'static str,
599            _variants: &'static [&'static str],
600            visitor: V,
601        ) -> Result<V::Value, Self::Error>
602        where
603            V: Visitor<'de>,
604        {
605            self.delegate.deserialize_any(SingletonMapAsEnum {
606                name,
607                delegate: visitor,
608            })
609        }
610
611        fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
612        where
613            V: Visitor<'de>,
614        {
615            self.delegate.deserialize_identifier(visitor)
616        }
617
618        fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
619        where
620            V: Visitor<'de>,
621        {
622            self.delegate.deserialize_ignored_any(visitor)
623        }
624
625        fn is_human_readable(&self) -> bool {
626            self.delegate.is_human_readable()
627        }
628    }
629
630    struct SingletonMapAsEnum<D> {
631        name: &'static str,
632        delegate: D,
633    }
634
635    impl<'de, V> Visitor<'de> for SingletonMapAsEnum<V>
636    where
637        V: Visitor<'de>,
638    {
639        type Value = V::Value;
640
641        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
642            self.delegate.expecting(formatter)
643        }
644
645        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
646        where
647            E: de::Error,
648        {
649            self.delegate.visit_enum(de::value::StrDeserializer::new(v))
650        }
651
652        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
653        where
654            E: de::Error,
655        {
656            self.delegate.visit_enum(de::value::BorrowedStrDeserializer::new(v))
657        }
658
659        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
660        where
661            E: de::Error,
662        {
663            self.delegate.visit_enum(de::value::StringDeserializer::new(v))
664        }
665
666        fn visit_none<E>(self) -> Result<Self::Value, E>
667        where
668            E: de::Error,
669        {
670            self.delegate.visit_none()
671        }
672
673        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
674        where
675            D: Deserializer<'de>,
676        {
677            self.delegate.visit_some(SingletonMap {
678                delegate: deserializer,
679            })
680        }
681
682        fn visit_unit<E>(self) -> Result<Self::Value, E>
683        where
684            E: de::Error,
685        {
686            self.delegate.visit_unit()
687        }
688
689        fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
690        where
691            A: MapAccess<'de>,
692        {
693            self.delegate.visit_enum(SingletonMapAsEnum {
694                name: self.name,
695                delegate: map,
696            })
697        }
698    }
699
700    impl<'de, D> EnumAccess<'de> for SingletonMapAsEnum<D>
701    where
702        D: MapAccess<'de>,
703    {
704        type Error = D::Error;
705        type Variant = Self;
706
707        fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
708        where
709            V: DeserializeSeed<'de>,
710        {
711            match self.delegate.next_key_seed(seed)? {
712                Some(value) => Ok((value, self)),
713                None => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
714            }
715        }
716    }
717
718    impl<'de, D> VariantAccess<'de> for SingletonMapAsEnum<D>
719    where
720        D: MapAccess<'de>,
721    {
722        type Error = D::Error;
723
724        fn unit_variant(self) -> Result<(), Self::Error> {
725            Err(de::Error::invalid_type(Unexpected::Map, &"unit variant"))
726        }
727
728        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
729        where
730            T: DeserializeSeed<'de>,
731        {
732            let value = self.delegate.next_value_seed(seed)?;
733            match self.delegate.next_key()? {
734                None => Ok(value),
735                Some(IgnoredAny) => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
736            }
737        }
738
739        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
740        where
741            V: Visitor<'de>,
742        {
743            let value = self.delegate.next_value_seed(TupleVariantSeed {
744                len,
745                visitor,
746            })?;
747            match self.delegate.next_key()? {
748                None => Ok(value),
749                Some(IgnoredAny) => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
750            }
751        }
752
753        fn struct_variant<V>(mut self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
754        where
755            V: Visitor<'de>,
756        {
757            let value = self.delegate.next_value_seed(StructVariantSeed {
758                name: self.name,
759                fields,
760                visitor,
761            })?;
762            match self.delegate.next_key()? {
763                None => Ok(value),
764                Some(IgnoredAny) => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
765            }
766        }
767    }
768
769    struct TupleVariantSeed<V> {
770        len: usize,
771        visitor: V,
772    }
773
774    impl<'de, V> DeserializeSeed<'de> for TupleVariantSeed<V>
775    where
776        V: Visitor<'de>,
777    {
778        type Value = V::Value;
779
780        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
781        where
782            D: Deserializer<'de>,
783        {
784            deserializer.deserialize_tuple(self.len, self.visitor)
785        }
786    }
787
788    struct StructVariantSeed<V> {
789        name: &'static str,
790        fields: &'static [&'static str],
791        visitor: V,
792    }
793
794    impl<'de, V> DeserializeSeed<'de> for StructVariantSeed<V>
795    where
796        V: Visitor<'de>,
797    {
798        type Value = V::Value;
799
800        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
801        where
802            D: Deserializer<'de>,
803        {
804            deserializer.deserialize_struct(self.name, self.fields, self.visitor)
805        }
806    }
807}
808
809/// Apply [`singleton_map`] to *all* enums contained within the data structure.
810///
811/// # Example
812///
813/// ```
814/// # use serde_derive::{Deserialize, Serialize};
815/// use serde::{Deserialize, Serialize};
816///
817/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
818/// enum Enum {
819///     Int(i32),
820/// }
821///
822/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
823/// struct Inner {
824///     a: Enum,
825///     bs: Vec<Enum>,
826/// }
827///
828/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
829/// struct Outer {
830///     tagged_style: Inner,
831///
832///     #[serde(with = "serde_yaml::with::singleton_map_recursive")]
833///     singleton_map_style: Inner,
834/// }
835///
836/// fn main() {
837///     let object = Outer {
838///         tagged_style: Inner {
839///             a: Enum::Int(0),
840///             bs: vec![Enum::Int(1)],
841///         },
842///         singleton_map_style: Inner {
843///             a: Enum::Int(2),
844///             bs: vec![Enum::Int(3)],
845///         },
846///     };
847///
848///     let yaml = serde_yaml::to_string(&object).unwrap();
849///     print!("{}", yaml);
850///
851///     let deserialized: Outer = serde_yaml::from_str(&yaml).unwrap();
852///     assert_eq!(object, deserialized);
853/// }
854/// ```
855///
856/// The serialized output is:
857///
858/// ```yaml
859/// tagged_style:
860///   a: !Int 0
861///   bs:
862///   - !Int 1
863/// singleton_map_style:
864///   a:
865///     Int: 2
866///   bs:
867///   - Int: 3
868/// ```
869///
870/// This module can also be used for the top-level serializer or deserializer
871/// call, without `serde(with = …)`, as follows.
872///
873/// ```
874/// # use serde_derive::{Deserialize, Serialize};
875/// # use serde::{Deserialize, Serialize};
876/// #
877/// # #[derive(Serialize, Deserialize, PartialEq, Debug)]
878/// # enum Enum {
879/// #     Int(i32),
880/// # }
881/// #
882/// # #[derive(Serialize, Deserialize, PartialEq, Debug)]
883/// # struct Inner {
884/// #     a: Enum,
885/// #     bs: Vec<Enum>,
886/// # }
887/// #
888/// use std::io::{self, Write};
889///
890/// fn main() {
891///     let object = Inner {
892///         a: Enum::Int(0),
893///         bs: vec![Enum::Int(1)],
894///     };
895///
896///     let mut buf = Vec::new();
897///     let mut serializer = serde_yaml::Serializer::new(&mut buf);
898///     serde_yaml::with::singleton_map_recursive::serialize(&object, &mut serializer).unwrap();
899///     io::stdout().write_all(&buf).unwrap();
900///
901///     let deserializer = serde_yaml::Deserializer::from_slice(&buf);
902///     let deserialized: Inner = serde_yaml::with::singleton_map_recursive::deserialize(deserializer).unwrap();
903///     assert_eq!(object, deserialized);
904/// }
905/// ```
906pub mod singleton_map_recursive {
907    use std::fmt::{self, Display};
908
909    use serde::{
910        de::{
911            self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, IgnoredAny, MapAccess, SeqAccess, Unexpected,
912            VariantAccess, Visitor,
913        },
914        ser::{
915            self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
916            SerializeTupleStruct, SerializeTupleVariant, Serializer,
917        },
918    };
919
920    use crate::value::{Mapping, Sequence, Value};
921
922    #[allow(missing_docs)]
923    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
924    where
925        T: Serialize,
926        S: Serializer,
927    {
928        value.serialize(SingletonMapRecursive {
929            delegate: serializer,
930        })
931    }
932
933    #[allow(missing_docs)]
934    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
935    where
936        T: Deserialize<'de>,
937        D: Deserializer<'de>,
938    {
939        T::deserialize(SingletonMapRecursive {
940            delegate: deserializer,
941        })
942    }
943
944    struct SingletonMapRecursive<D> {
945        delegate: D,
946    }
947
948    impl<D> Serialize for SingletonMapRecursive<D>
949    where
950        D: Serialize,
951    {
952        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
953        where
954            S: Serializer,
955        {
956            self.delegate.serialize(SingletonMapRecursive {
957                delegate: serializer,
958            })
959        }
960    }
961
962    impl<D> Serializer for SingletonMapRecursive<D>
963    where
964        D: Serializer,
965    {
966        type Ok = D::Ok;
967        type Error = D::Error;
968
969        type SerializeSeq = SingletonMapRecursive<D::SerializeSeq>;
970        type SerializeTuple = SingletonMapRecursive<D::SerializeTuple>;
971        type SerializeTupleStruct = SingletonMapRecursive<D::SerializeTupleStruct>;
972        type SerializeTupleVariant = SerializeTupleVariantAsSingletonMapRecursive<D::SerializeMap>;
973        type SerializeMap = SingletonMapRecursive<D::SerializeMap>;
974        type SerializeStruct = SingletonMapRecursive<D::SerializeStruct>;
975        type SerializeStructVariant = SerializeStructVariantAsSingletonMapRecursive<D::SerializeMap>;
976
977        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
978            self.delegate.serialize_bool(v)
979        }
980
981        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
982            self.delegate.serialize_i8(v)
983        }
984
985        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
986            self.delegate.serialize_i16(v)
987        }
988
989        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
990            self.delegate.serialize_i32(v)
991        }
992
993        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
994            self.delegate.serialize_i64(v)
995        }
996
997        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
998            self.delegate.serialize_i128(v)
999        }
1000
1001        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
1002            self.delegate.serialize_u8(v)
1003        }
1004
1005        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
1006            self.delegate.serialize_u16(v)
1007        }
1008
1009        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
1010            self.delegate.serialize_u32(v)
1011        }
1012
1013        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
1014            self.delegate.serialize_u64(v)
1015        }
1016
1017        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
1018            self.delegate.serialize_u128(v)
1019        }
1020
1021        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
1022            self.delegate.serialize_f32(v)
1023        }
1024
1025        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
1026            self.delegate.serialize_f64(v)
1027        }
1028
1029        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
1030            self.delegate.serialize_char(v)
1031        }
1032
1033        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
1034            self.delegate.serialize_str(v)
1035        }
1036
1037        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
1038            self.delegate.serialize_bytes(v)
1039        }
1040
1041        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
1042            self.delegate.serialize_unit()
1043        }
1044
1045        fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
1046            self.delegate.serialize_unit_struct(name)
1047        }
1048
1049        fn serialize_unit_variant(
1050            self,
1051            name: &'static str,
1052            variant_index: u32,
1053            variant: &'static str,
1054        ) -> Result<Self::Ok, Self::Error> {
1055            self.delegate.serialize_unit_variant(name, variant_index, variant)
1056        }
1057
1058        fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
1059        where
1060            T: ?Sized + Serialize,
1061        {
1062            self.delegate.serialize_newtype_struct(
1063                name,
1064                &SingletonMapRecursive {
1065                    delegate: value,
1066                },
1067            )
1068        }
1069
1070        fn serialize_newtype_variant<T>(
1071            self,
1072            _name: &'static str,
1073            _variant_index: u32,
1074            variant: &'static str,
1075            value: &T,
1076        ) -> Result<Self::Ok, Self::Error>
1077        where
1078            T: ?Sized + Serialize,
1079        {
1080            let mut map = self.delegate.serialize_map(Some(1))?;
1081            map.serialize_entry(
1082                variant,
1083                &SingletonMapRecursive {
1084                    delegate: value,
1085                },
1086            )?;
1087            map.end()
1088        }
1089
1090        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
1091            self.delegate.serialize_none()
1092        }
1093
1094        fn serialize_some<V>(self, value: &V) -> Result<Self::Ok, Self::Error>
1095        where
1096            V: ?Sized + Serialize,
1097        {
1098            self.delegate.serialize_some(&SingletonMapRecursive {
1099                delegate: value,
1100            })
1101        }
1102
1103        fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
1104            Ok(SingletonMapRecursive {
1105                delegate: self.delegate.serialize_seq(len)?,
1106            })
1107        }
1108
1109        fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
1110            Ok(SingletonMapRecursive {
1111                delegate: self.delegate.serialize_tuple(len)?,
1112            })
1113        }
1114
1115        fn serialize_tuple_struct(
1116            self,
1117            name: &'static str,
1118            len: usize,
1119        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
1120            Ok(SingletonMapRecursive {
1121                delegate: self.delegate.serialize_tuple_struct(name, len)?,
1122            })
1123        }
1124
1125        fn serialize_tuple_variant(
1126            self,
1127            _name: &'static str,
1128            _variant_index: u32,
1129            variant: &'static str,
1130            len: usize,
1131        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
1132            let mut map = self.delegate.serialize_map(Some(1))?;
1133            map.serialize_key(variant)?;
1134            let sequence = Sequence::with_capacity(len);
1135            Ok(SerializeTupleVariantAsSingletonMapRecursive {
1136                map,
1137                sequence,
1138            })
1139        }
1140
1141        fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
1142            Ok(SingletonMapRecursive {
1143                delegate: self.delegate.serialize_map(len)?,
1144            })
1145        }
1146
1147        fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
1148            Ok(SingletonMapRecursive {
1149                delegate: self.delegate.serialize_struct(name, len)?,
1150            })
1151        }
1152
1153        fn serialize_struct_variant(
1154            self,
1155            _name: &'static str,
1156            _variant_index: u32,
1157            variant: &'static str,
1158            len: usize,
1159        ) -> Result<Self::SerializeStructVariant, Self::Error> {
1160            let mut map = self.delegate.serialize_map(Some(1))?;
1161            map.serialize_key(variant)?;
1162            let mapping = Mapping::with_capacity(len);
1163            Ok(SerializeStructVariantAsSingletonMapRecursive {
1164                map,
1165                mapping,
1166            })
1167        }
1168
1169        fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
1170        where
1171            T: ?Sized + Display,
1172        {
1173            self.delegate.collect_str(value)
1174        }
1175
1176        fn is_human_readable(&self) -> bool {
1177            self.delegate.is_human_readable()
1178        }
1179    }
1180
1181    impl<D> SerializeSeq for SingletonMapRecursive<D>
1182    where
1183        D: SerializeSeq,
1184    {
1185        type Ok = D::Ok;
1186        type Error = D::Error;
1187
1188        fn serialize_element<T>(&mut self, elem: &T) -> Result<(), Self::Error>
1189        where
1190            T: ?Sized + ser::Serialize,
1191        {
1192            self.delegate.serialize_element(&SingletonMapRecursive {
1193                delegate: elem,
1194            })
1195        }
1196
1197        fn end(self) -> Result<Self::Ok, Self::Error> {
1198            self.delegate.end()
1199        }
1200    }
1201
1202    impl<D> SerializeTuple for SingletonMapRecursive<D>
1203    where
1204        D: SerializeTuple,
1205    {
1206        type Ok = D::Ok;
1207        type Error = D::Error;
1208
1209        fn serialize_element<T>(&mut self, elem: &T) -> Result<(), Self::Error>
1210        where
1211            T: ?Sized + ser::Serialize,
1212        {
1213            self.delegate.serialize_element(&SingletonMapRecursive {
1214                delegate: elem,
1215            })
1216        }
1217
1218        fn end(self) -> Result<Self::Ok, Self::Error> {
1219            self.delegate.end()
1220        }
1221    }
1222
1223    impl<D> SerializeTupleStruct for SingletonMapRecursive<D>
1224    where
1225        D: SerializeTupleStruct,
1226    {
1227        type Ok = D::Ok;
1228        type Error = D::Error;
1229
1230        fn serialize_field<V>(&mut self, value: &V) -> Result<(), Self::Error>
1231        where
1232            V: ?Sized + ser::Serialize,
1233        {
1234            self.delegate.serialize_field(&SingletonMapRecursive {
1235                delegate: value,
1236            })
1237        }
1238
1239        fn end(self) -> Result<Self::Ok, Self::Error> {
1240            self.delegate.end()
1241        }
1242    }
1243
1244    struct SerializeTupleVariantAsSingletonMapRecursive<M> {
1245        map: M,
1246        sequence: Sequence,
1247    }
1248
1249    impl<M> SerializeTupleVariant for SerializeTupleVariantAsSingletonMapRecursive<M>
1250    where
1251        M: SerializeMap,
1252    {
1253        type Ok = M::Ok;
1254        type Error = M::Error;
1255
1256        fn serialize_field<T>(&mut self, field: &T) -> Result<(), Self::Error>
1257        where
1258            T: ?Sized + Serialize,
1259        {
1260            let value = field
1261                .serialize(SingletonMapRecursive {
1262                    delegate: crate::value::Serializer,
1263                })
1264                .map_err(ser::Error::custom)?;
1265            self.sequence.push(value);
1266            Ok(())
1267        }
1268
1269        fn end(mut self) -> Result<Self::Ok, Self::Error> {
1270            self.map.serialize_value(&self.sequence)?;
1271            self.map.end()
1272        }
1273    }
1274
1275    impl<D> SerializeMap for SingletonMapRecursive<D>
1276    where
1277        D: SerializeMap,
1278    {
1279        type Ok = D::Ok;
1280        type Error = D::Error;
1281
1282        fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
1283        where
1284            T: ?Sized + ser::Serialize,
1285        {
1286            self.delegate.serialize_key(&SingletonMapRecursive {
1287                delegate: key,
1288            })
1289        }
1290
1291        fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
1292        where
1293            T: ?Sized + ser::Serialize,
1294        {
1295            self.delegate.serialize_value(&SingletonMapRecursive {
1296                delegate: value,
1297            })
1298        }
1299
1300        fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
1301        where
1302            K: ?Sized + ser::Serialize,
1303            V: ?Sized + ser::Serialize,
1304        {
1305            self.delegate.serialize_entry(
1306                &SingletonMapRecursive {
1307                    delegate: key,
1308                },
1309                &SingletonMapRecursive {
1310                    delegate: value,
1311                },
1312            )
1313        }
1314
1315        fn end(self) -> Result<Self::Ok, Self::Error> {
1316            self.delegate.end()
1317        }
1318    }
1319
1320    impl<D> SerializeStruct for SingletonMapRecursive<D>
1321    where
1322        D: SerializeStruct,
1323    {
1324        type Ok = D::Ok;
1325        type Error = D::Error;
1326
1327        fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<(), Self::Error>
1328        where
1329            V: ?Sized + ser::Serialize,
1330        {
1331            self.delegate.serialize_field(
1332                key,
1333                &SingletonMapRecursive {
1334                    delegate: value,
1335                },
1336            )
1337        }
1338
1339        fn end(self) -> Result<Self::Ok, Self::Error> {
1340            self.delegate.end()
1341        }
1342    }
1343
1344    struct SerializeStructVariantAsSingletonMapRecursive<M> {
1345        map: M,
1346        mapping: Mapping,
1347    }
1348
1349    impl<M> SerializeStructVariant for SerializeStructVariantAsSingletonMapRecursive<M>
1350    where
1351        M: SerializeMap,
1352    {
1353        type Ok = M::Ok;
1354        type Error = M::Error;
1355
1356        fn serialize_field<T>(&mut self, name: &'static str, field: &T) -> Result<(), Self::Error>
1357        where
1358            T: ?Sized + Serialize,
1359        {
1360            let value = field
1361                .serialize(SingletonMapRecursive {
1362                    delegate: crate::value::Serializer,
1363                })
1364                .map_err(ser::Error::custom)?;
1365            self.mapping.insert(Value::String(name.to_owned()), value);
1366            Ok(())
1367        }
1368
1369        fn end(mut self) -> Result<Self::Ok, Self::Error> {
1370            self.map.serialize_value(&self.mapping)?;
1371            self.map.end()
1372        }
1373    }
1374
1375    impl<'de, D> Deserializer<'de> for SingletonMapRecursive<D>
1376    where
1377        D: Deserializer<'de>,
1378    {
1379        type Error = D::Error;
1380
1381        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1382        where
1383            V: Visitor<'de>,
1384        {
1385            self.delegate.deserialize_any(SingletonMapRecursive {
1386                delegate: visitor,
1387            })
1388        }
1389
1390        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1391        where
1392            V: Visitor<'de>,
1393        {
1394            self.delegate.deserialize_bool(SingletonMapRecursive {
1395                delegate: visitor,
1396            })
1397        }
1398
1399        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1400        where
1401            V: Visitor<'de>,
1402        {
1403            self.delegate.deserialize_i8(SingletonMapRecursive {
1404                delegate: visitor,
1405            })
1406        }
1407
1408        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1409        where
1410            V: Visitor<'de>,
1411        {
1412            self.delegate.deserialize_i16(SingletonMapRecursive {
1413                delegate: visitor,
1414            })
1415        }
1416
1417        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1418        where
1419            V: Visitor<'de>,
1420        {
1421            self.delegate.deserialize_i32(SingletonMapRecursive {
1422                delegate: visitor,
1423            })
1424        }
1425
1426        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1427        where
1428            V: Visitor<'de>,
1429        {
1430            self.delegate.deserialize_i64(SingletonMapRecursive {
1431                delegate: visitor,
1432            })
1433        }
1434
1435        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1436        where
1437            V: Visitor<'de>,
1438        {
1439            self.delegate.deserialize_i128(SingletonMapRecursive {
1440                delegate: visitor,
1441            })
1442        }
1443
1444        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1445        where
1446            V: Visitor<'de>,
1447        {
1448            self.delegate.deserialize_u8(SingletonMapRecursive {
1449                delegate: visitor,
1450            })
1451        }
1452
1453        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1454        where
1455            V: Visitor<'de>,
1456        {
1457            self.delegate.deserialize_u16(SingletonMapRecursive {
1458                delegate: visitor,
1459            })
1460        }
1461
1462        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1463        where
1464            V: Visitor<'de>,
1465        {
1466            self.delegate.deserialize_u32(SingletonMapRecursive {
1467                delegate: visitor,
1468            })
1469        }
1470
1471        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1472        where
1473            V: Visitor<'de>,
1474        {
1475            self.delegate.deserialize_u64(SingletonMapRecursive {
1476                delegate: visitor,
1477            })
1478        }
1479
1480        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1481        where
1482            V: Visitor<'de>,
1483        {
1484            self.delegate.deserialize_u128(SingletonMapRecursive {
1485                delegate: visitor,
1486            })
1487        }
1488
1489        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1490        where
1491            V: Visitor<'de>,
1492        {
1493            self.delegate.deserialize_f32(SingletonMapRecursive {
1494                delegate: visitor,
1495            })
1496        }
1497
1498        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1499        where
1500            V: Visitor<'de>,
1501        {
1502            self.delegate.deserialize_f64(SingletonMapRecursive {
1503                delegate: visitor,
1504            })
1505        }
1506
1507        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1508        where
1509            V: Visitor<'de>,
1510        {
1511            self.delegate.deserialize_char(SingletonMapRecursive {
1512                delegate: visitor,
1513            })
1514        }
1515
1516        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1517        where
1518            V: Visitor<'de>,
1519        {
1520            self.delegate.deserialize_str(SingletonMapRecursive {
1521                delegate: visitor,
1522            })
1523        }
1524
1525        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1526        where
1527            V: Visitor<'de>,
1528        {
1529            self.delegate.deserialize_string(SingletonMapRecursive {
1530                delegate: visitor,
1531            })
1532        }
1533
1534        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1535        where
1536            V: Visitor<'de>,
1537        {
1538            self.delegate.deserialize_bytes(SingletonMapRecursive {
1539                delegate: visitor,
1540            })
1541        }
1542
1543        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1544        where
1545            V: Visitor<'de>,
1546        {
1547            self.delegate.deserialize_byte_buf(SingletonMapRecursive {
1548                delegate: visitor,
1549            })
1550        }
1551
1552        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1553        where
1554            V: Visitor<'de>,
1555        {
1556            self.delegate.deserialize_option(SingletonMapRecursiveAsEnum {
1557                name: "",
1558                delegate: visitor,
1559            })
1560        }
1561
1562        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1563        where
1564            V: Visitor<'de>,
1565        {
1566            self.delegate.deserialize_unit(SingletonMapRecursive {
1567                delegate: visitor,
1568            })
1569        }
1570
1571        fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
1572        where
1573            V: Visitor<'de>,
1574        {
1575            self.delegate.deserialize_unit_struct(
1576                name,
1577                SingletonMapRecursive {
1578                    delegate: visitor,
1579                },
1580            )
1581        }
1582
1583        fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
1584        where
1585            V: Visitor<'de>,
1586        {
1587            self.delegate.deserialize_newtype_struct(
1588                name,
1589                SingletonMapRecursive {
1590                    delegate: visitor,
1591                },
1592            )
1593        }
1594
1595        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1596        where
1597            V: Visitor<'de>,
1598        {
1599            self.delegate.deserialize_seq(SingletonMapRecursive {
1600                delegate: visitor,
1601            })
1602        }
1603
1604        fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
1605        where
1606            V: Visitor<'de>,
1607        {
1608            self.delegate.deserialize_tuple(
1609                len,
1610                SingletonMapRecursive {
1611                    delegate: visitor,
1612                },
1613            )
1614        }
1615
1616        fn deserialize_tuple_struct<V>(
1617            self,
1618            name: &'static str,
1619            len: usize,
1620            visitor: V,
1621        ) -> Result<V::Value, Self::Error>
1622        where
1623            V: Visitor<'de>,
1624        {
1625            self.delegate.deserialize_tuple_struct(
1626                name,
1627                len,
1628                SingletonMapRecursive {
1629                    delegate: visitor,
1630                },
1631            )
1632        }
1633
1634        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1635        where
1636            V: Visitor<'de>,
1637        {
1638            self.delegate.deserialize_map(SingletonMapRecursive {
1639                delegate: visitor,
1640            })
1641        }
1642
1643        fn deserialize_struct<V>(
1644            self,
1645            name: &'static str,
1646            fields: &'static [&'static str],
1647            visitor: V,
1648        ) -> Result<V::Value, Self::Error>
1649        where
1650            V: Visitor<'de>,
1651        {
1652            self.delegate.deserialize_struct(
1653                name,
1654                fields,
1655                SingletonMapRecursive {
1656                    delegate: visitor,
1657                },
1658            )
1659        }
1660
1661        fn deserialize_enum<V>(
1662            self,
1663            name: &'static str,
1664            _variants: &'static [&'static str],
1665            visitor: V,
1666        ) -> Result<V::Value, Self::Error>
1667        where
1668            V: Visitor<'de>,
1669        {
1670            self.delegate.deserialize_any(SingletonMapRecursiveAsEnum {
1671                name,
1672                delegate: visitor,
1673            })
1674        }
1675
1676        fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1677        where
1678            V: Visitor<'de>,
1679        {
1680            self.delegate.deserialize_identifier(SingletonMapRecursive {
1681                delegate: visitor,
1682            })
1683        }
1684
1685        fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1686        where
1687            V: Visitor<'de>,
1688        {
1689            self.delegate.deserialize_ignored_any(SingletonMapRecursive {
1690                delegate: visitor,
1691            })
1692        }
1693
1694        fn is_human_readable(&self) -> bool {
1695            self.delegate.is_human_readable()
1696        }
1697    }
1698
1699    impl<'de, V> Visitor<'de> for SingletonMapRecursive<V>
1700    where
1701        V: Visitor<'de>,
1702    {
1703        type Value = V::Value;
1704
1705        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1706            self.delegate.expecting(formatter)
1707        }
1708
1709        fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
1710        where
1711            E: de::Error,
1712        {
1713            self.delegate.visit_bool(v)
1714        }
1715
1716        fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
1717        where
1718            E: de::Error,
1719        {
1720            self.delegate.visit_i8(v)
1721        }
1722
1723        fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
1724        where
1725            E: de::Error,
1726        {
1727            self.delegate.visit_i16(v)
1728        }
1729
1730        fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
1731        where
1732            E: de::Error,
1733        {
1734            self.delegate.visit_i32(v)
1735        }
1736
1737        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
1738        where
1739            E: de::Error,
1740        {
1741            self.delegate.visit_i64(v)
1742        }
1743
1744        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
1745        where
1746            E: de::Error,
1747        {
1748            self.delegate.visit_i128(v)
1749        }
1750
1751        fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
1752        where
1753            E: de::Error,
1754        {
1755            self.delegate.visit_u8(v)
1756        }
1757
1758        fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
1759        where
1760            E: de::Error,
1761        {
1762            self.delegate.visit_u16(v)
1763        }
1764
1765        fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
1766        where
1767            E: de::Error,
1768        {
1769            self.delegate.visit_u32(v)
1770        }
1771
1772        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
1773        where
1774            E: de::Error,
1775        {
1776            self.delegate.visit_u64(v)
1777        }
1778
1779        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
1780        where
1781            E: de::Error,
1782        {
1783            self.delegate.visit_u128(v)
1784        }
1785
1786        fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
1787        where
1788            E: de::Error,
1789        {
1790            self.delegate.visit_f32(v)
1791        }
1792
1793        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
1794        where
1795            E: de::Error,
1796        {
1797            self.delegate.visit_f64(v)
1798        }
1799
1800        fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
1801        where
1802            E: de::Error,
1803        {
1804            self.delegate.visit_char(v)
1805        }
1806
1807        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1808        where
1809            E: de::Error,
1810        {
1811            self.delegate.visit_str(v)
1812        }
1813
1814        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
1815        where
1816            E: de::Error,
1817        {
1818            self.delegate.visit_borrowed_str(v)
1819        }
1820
1821        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1822        where
1823            E: de::Error,
1824        {
1825            self.delegate.visit_string(v)
1826        }
1827
1828        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
1829        where
1830            E: de::Error,
1831        {
1832            self.delegate.visit_bytes(v)
1833        }
1834
1835        fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
1836        where
1837            E: de::Error,
1838        {
1839            self.delegate.visit_borrowed_bytes(v)
1840        }
1841
1842        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
1843        where
1844            E: de::Error,
1845        {
1846            self.delegate.visit_byte_buf(v)
1847        }
1848
1849        fn visit_none<E>(self) -> Result<Self::Value, E>
1850        where
1851            E: de::Error,
1852        {
1853            self.delegate.visit_none()
1854        }
1855
1856        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1857        where
1858            D: Deserializer<'de>,
1859        {
1860            self.delegate.visit_some(SingletonMapRecursive {
1861                delegate: deserializer,
1862            })
1863        }
1864
1865        fn visit_unit<E>(self) -> Result<Self::Value, E>
1866        where
1867            E: de::Error,
1868        {
1869            self.delegate.visit_unit()
1870        }
1871
1872        fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1873        where
1874            D: Deserializer<'de>,
1875        {
1876            self.delegate.visit_newtype_struct(SingletonMapRecursive {
1877                delegate: deserializer,
1878            })
1879        }
1880
1881        fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
1882        where
1883            A: SeqAccess<'de>,
1884        {
1885            self.delegate.visit_seq(SingletonMapRecursive {
1886                delegate: seq,
1887            })
1888        }
1889
1890        fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
1891        where
1892            A: MapAccess<'de>,
1893        {
1894            self.delegate.visit_map(SingletonMapRecursive {
1895                delegate: map,
1896            })
1897        }
1898    }
1899
1900    impl<'de, T> DeserializeSeed<'de> for SingletonMapRecursive<T>
1901    where
1902        T: DeserializeSeed<'de>,
1903    {
1904        type Value = T::Value;
1905
1906        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1907        where
1908            D: Deserializer<'de>,
1909        {
1910            self.delegate.deserialize(SingletonMapRecursive {
1911                delegate: deserializer,
1912            })
1913        }
1914    }
1915
1916    impl<'de, S> SeqAccess<'de> for SingletonMapRecursive<S>
1917    where
1918        S: SeqAccess<'de>,
1919    {
1920        type Error = S::Error;
1921
1922        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1923        where
1924            T: DeserializeSeed<'de>,
1925        {
1926            self.delegate.next_element_seed(SingletonMapRecursive {
1927                delegate: seed,
1928            })
1929        }
1930    }
1931
1932    impl<'de, M> MapAccess<'de> for SingletonMapRecursive<M>
1933    where
1934        M: MapAccess<'de>,
1935    {
1936        type Error = M::Error;
1937
1938        fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
1939        where
1940            K: DeserializeSeed<'de>,
1941        {
1942            self.delegate.next_key_seed(SingletonMapRecursive {
1943                delegate: seed,
1944            })
1945        }
1946
1947        fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
1948        where
1949            V: DeserializeSeed<'de>,
1950        {
1951            self.delegate.next_value_seed(SingletonMapRecursive {
1952                delegate: seed,
1953            })
1954        }
1955    }
1956
1957    struct SingletonMapRecursiveAsEnum<D> {
1958        name: &'static str,
1959        delegate: D,
1960    }
1961
1962    impl<'de, V> Visitor<'de> for SingletonMapRecursiveAsEnum<V>
1963    where
1964        V: Visitor<'de>,
1965    {
1966        type Value = V::Value;
1967
1968        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1969            self.delegate.expecting(formatter)
1970        }
1971
1972        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1973        where
1974            E: de::Error,
1975        {
1976            self.delegate.visit_enum(de::value::StrDeserializer::new(v))
1977        }
1978
1979        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
1980        where
1981            E: de::Error,
1982        {
1983            self.delegate.visit_enum(de::value::BorrowedStrDeserializer::new(v))
1984        }
1985
1986        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1987        where
1988            E: de::Error,
1989        {
1990            self.delegate.visit_enum(de::value::StringDeserializer::new(v))
1991        }
1992
1993        fn visit_none<E>(self) -> Result<Self::Value, E>
1994        where
1995            E: de::Error,
1996        {
1997            self.delegate.visit_none()
1998        }
1999
2000        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
2001        where
2002            D: Deserializer<'de>,
2003        {
2004            self.delegate.visit_some(SingletonMapRecursive {
2005                delegate: deserializer,
2006            })
2007        }
2008
2009        fn visit_unit<E>(self) -> Result<Self::Value, E>
2010        where
2011            E: de::Error,
2012        {
2013            self.delegate.visit_unit()
2014        }
2015
2016        fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
2017        where
2018            A: MapAccess<'de>,
2019        {
2020            self.delegate.visit_enum(SingletonMapRecursiveAsEnum {
2021                name: self.name,
2022                delegate: map,
2023            })
2024        }
2025    }
2026
2027    impl<'de, D> EnumAccess<'de> for SingletonMapRecursiveAsEnum<D>
2028    where
2029        D: MapAccess<'de>,
2030    {
2031        type Error = D::Error;
2032        type Variant = Self;
2033
2034        fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
2035        where
2036            V: DeserializeSeed<'de>,
2037        {
2038            match self.delegate.next_key_seed(seed)? {
2039                Some(value) => Ok((value, self)),
2040                None => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
2041            }
2042        }
2043    }
2044
2045    impl<'de, D> VariantAccess<'de> for SingletonMapRecursiveAsEnum<D>
2046    where
2047        D: MapAccess<'de>,
2048    {
2049        type Error = D::Error;
2050
2051        fn unit_variant(self) -> Result<(), Self::Error> {
2052            Err(de::Error::invalid_type(Unexpected::Map, &"unit variant"))
2053        }
2054
2055        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
2056        where
2057            T: DeserializeSeed<'de>,
2058        {
2059            let value = self.delegate.next_value_seed(SingletonMapRecursive {
2060                delegate: seed,
2061            })?;
2062            match self.delegate.next_key()? {
2063                None => Ok(value),
2064                Some(IgnoredAny) => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
2065            }
2066        }
2067
2068        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
2069        where
2070            V: Visitor<'de>,
2071        {
2072            let value = self.delegate.next_value_seed(TupleVariantSeed {
2073                len,
2074                visitor: SingletonMapRecursive {
2075                    delegate: visitor,
2076                },
2077            })?;
2078            match self.delegate.next_key()? {
2079                None => Ok(value),
2080                Some(IgnoredAny) => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
2081            }
2082        }
2083
2084        fn struct_variant<V>(mut self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
2085        where
2086            V: Visitor<'de>,
2087        {
2088            let value = self.delegate.next_value_seed(StructVariantSeed {
2089                name: self.name,
2090                fields,
2091                visitor: SingletonMapRecursive {
2092                    delegate: visitor,
2093                },
2094            })?;
2095            match self.delegate.next_key()? {
2096                None => Ok(value),
2097                Some(IgnoredAny) => Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")),
2098            }
2099        }
2100    }
2101
2102    struct TupleVariantSeed<V> {
2103        len: usize,
2104        visitor: V,
2105    }
2106
2107    impl<'de, V> DeserializeSeed<'de> for TupleVariantSeed<V>
2108    where
2109        V: Visitor<'de>,
2110    {
2111        type Value = V::Value;
2112
2113        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
2114        where
2115            D: Deserializer<'de>,
2116        {
2117            deserializer.deserialize_tuple(self.len, self.visitor)
2118        }
2119    }
2120
2121    struct StructVariantSeed<V> {
2122        name: &'static str,
2123        fields: &'static [&'static str],
2124        visitor: V,
2125    }
2126
2127    impl<'de, V> DeserializeSeed<'de> for StructVariantSeed<V>
2128    where
2129        V: Visitor<'de>,
2130    {
2131        type Value = V::Value;
2132
2133        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
2134        where
2135            D: Deserializer<'de>,
2136        {
2137            deserializer.deserialize_struct(self.name, self.fields, self.visitor)
2138        }
2139    }
2140}
serde_yaml/with.rs

serde_yaml/
with.rs
