serde_yaml_ng/
with.rs

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

serde_yaml_ng/
with.rs
