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

serde_yaml/
with.rs
