serde_yaml/
with.rs

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

serde_yaml/
with.rs
