serde_yaml/value/
ser.rs

1use std::{fmt::Display, mem};
2
3use serde::ser::{self, Serialize};
4
5use crate::{
6    error::{self, Error, ErrorImpl},
7    value::{
8        Mapping, Number, Sequence, Tag, TaggedValue, Value,
9        tagged::{self, MaybeTag},
10        to_value,
11    },
12};
13
14type Result<T, E = Error> = std::result::Result<T, E>;
15
16impl Serialize for Value {
17    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
18    where
19        S: serde::Serializer,
20    {
21        match self {
22            Value::Null => serializer.serialize_unit(),
23            Value::Bool(b) => serializer.serialize_bool(*b),
24            Value::Number(n) => n.serialize(serializer),
25            Value::String(s) => serializer.serialize_str(s),
26            Value::Sequence(seq) => seq.serialize(serializer),
27            Value::Mapping(mapping) => {
28                use serde::ser::SerializeMap;
29                let mut map = serializer.serialize_map(Some(mapping.len()))?;
30                for (k, v) in mapping {
31                    map.serialize_entry(k, v)?;
32                }
33                map.end()
34            }
35            Value::Tagged(tagged) => tagged.serialize(serializer),
36        }
37    }
38}
39
40/// Serializer whose output is a `Value`.
41///
42/// This is the serializer that backs [`serde_yaml::to_value`][crate::to_value].
43/// Unlike the main serde_yaml serializer which goes from some serializable
44/// value of type `T` to YAML text, this one goes from `T` to
45/// `serde_yaml::Value`.
46///
47/// The `to_value` function is implementable as:
48///
49/// ```
50/// use serde::Serialize;
51/// use serde_yaml::{Error, Value};
52///
53/// pub fn to_value<T>(input: T) -> Result<Value, Error>
54/// where
55///     T: Serialize,
56/// {
57///     input.serialize(serde_yaml::value::Serializer)
58/// }
59/// ```
60pub struct Serializer;
61
62impl ser::Serializer for Serializer {
63    type Ok = Value;
64    type Error = Error;
65
66    type SerializeSeq = SerializeArray;
67    type SerializeTuple = SerializeArray;
68    type SerializeTupleStruct = SerializeArray;
69    type SerializeTupleVariant = SerializeTupleVariant;
70    type SerializeMap = SerializeMap;
71    type SerializeStruct = SerializeStruct;
72    type SerializeStructVariant = SerializeStructVariant;
73
74    fn serialize_bool(self, v: bool) -> Result<Value> {
75        Ok(Value::Bool(v))
76    }
77
78    fn serialize_i8(self, v: i8) -> Result<Value> {
79        Ok(Value::Number(Number::from(v)))
80    }
81
82    fn serialize_i16(self, v: i16) -> Result<Value> {
83        Ok(Value::Number(Number::from(v)))
84    }
85
86    fn serialize_i32(self, v: i32) -> Result<Value> {
87        Ok(Value::Number(Number::from(v)))
88    }
89
90    fn serialize_i64(self, v: i64) -> Result<Value> {
91        Ok(Value::Number(Number::from(v)))
92    }
93
94    fn serialize_i128(self, v: i128) -> Result<Value> {
95        if let Ok(v) = u64::try_from(v) {
96            self.serialize_u64(v)
97        } else if let Ok(v) = i64::try_from(v) {
98            self.serialize_i64(v)
99        } else {
100            Ok(Value::String(v.to_string()))
101        }
102    }
103
104    fn serialize_u8(self, v: u8) -> Result<Value> {
105        Ok(Value::Number(Number::from(v)))
106    }
107
108    fn serialize_u16(self, v: u16) -> Result<Value> {
109        Ok(Value::Number(Number::from(v)))
110    }
111
112    fn serialize_u32(self, v: u32) -> Result<Value> {
113        Ok(Value::Number(Number::from(v)))
114    }
115
116    fn serialize_u64(self, v: u64) -> Result<Value> {
117        Ok(Value::Number(Number::from(v)))
118    }
119
120    fn serialize_u128(self, v: u128) -> Result<Value> {
121        if let Ok(v) = u64::try_from(v) {
122            self.serialize_u64(v)
123        } else {
124            Ok(Value::String(v.to_string()))
125        }
126    }
127
128    fn serialize_f32(self, v: f32) -> Result<Value> {
129        Ok(Value::Number(Number::from(v)))
130    }
131
132    fn serialize_f64(self, v: f64) -> Result<Value> {
133        Ok(Value::Number(Number::from(v)))
134    }
135
136    fn serialize_char(self, value: char) -> Result<Value> {
137        Ok(Value::String(value.to_string()))
138    }
139
140    fn serialize_str(self, value: &str) -> Result<Value> {
141        Ok(Value::String(value.to_owned()))
142    }
143
144    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
145        let vec = value.iter().map(|&b| Value::Number(Number::from(b))).collect();
146        Ok(Value::Sequence(vec))
147    }
148
149    fn serialize_unit(self) -> Result<Value> {
150        Ok(Value::Null)
151    }
152
153    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
154        self.serialize_unit()
155    }
156
157    fn serialize_unit_variant(self, _name: &str, _variant_index: u32, variant: &str) -> Result<Value> {
158        Ok(Value::String(variant.to_owned()))
159    }
160
161    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
162    where
163        T: ?Sized + ser::Serialize,
164    {
165        value.serialize(self)
166    }
167
168    fn serialize_newtype_variant<T>(self, _name: &str, _variant_index: u32, variant: &str, value: &T) -> Result<Value>
169    where
170        T: ?Sized + ser::Serialize,
171    {
172        if variant.is_empty() {
173            return Err(error::new(ErrorImpl::EmptyTag));
174        }
175        Ok(Value::Tagged(Box::new(TaggedValue {
176            tag: Tag::new(variant),
177            value: to_value(value)?,
178        })))
179    }
180
181    fn serialize_none(self) -> Result<Value> {
182        self.serialize_unit()
183    }
184
185    fn serialize_some<V>(self, value: &V) -> Result<Value>
186    where
187        V: ?Sized + ser::Serialize,
188    {
189        value.serialize(self)
190    }
191
192    fn serialize_seq(self, len: Option<usize>) -> Result<SerializeArray> {
193        let sequence = match len {
194            None => Sequence::new(),
195            Some(len) => Sequence::with_capacity(len),
196        };
197        Ok(SerializeArray {
198            sequence,
199        })
200    }
201
202    fn serialize_tuple(self, len: usize) -> Result<SerializeArray> {
203        self.serialize_seq(Some(len))
204    }
205
206    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<SerializeArray> {
207        self.serialize_seq(Some(len))
208    }
209
210    fn serialize_tuple_variant(
211        self,
212        _enum: &'static str,
213        _idx: u32,
214        variant: &'static str,
215        len: usize,
216    ) -> Result<SerializeTupleVariant> {
217        if variant.is_empty() {
218            return Err(error::new(ErrorImpl::EmptyTag));
219        }
220        Ok(SerializeTupleVariant {
221            tag: variant,
222            sequence: Sequence::with_capacity(len),
223        })
224    }
225
226    fn serialize_map(self, len: Option<usize>) -> Result<SerializeMap> {
227        if len == Some(1) {
228            Ok(SerializeMap::CheckForTag)
229        } else {
230            Ok(SerializeMap::Untagged {
231                mapping: Mapping::new(),
232                next_key: None,
233            })
234        }
235    }
236
237    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<SerializeStruct> {
238        Ok(SerializeStruct {
239            mapping: Mapping::new(),
240        })
241    }
242
243    fn serialize_struct_variant(
244        self,
245        _enum: &'static str,
246        _idx: u32,
247        variant: &'static str,
248        _len: usize,
249    ) -> Result<SerializeStructVariant> {
250        if variant.is_empty() {
251            return Err(error::new(ErrorImpl::EmptyTag));
252        }
253        Ok(SerializeStructVariant {
254            tag: variant,
255            mapping: Mapping::new(),
256        })
257    }
258}
259
260pub struct SerializeArray {
261    sequence: Sequence,
262}
263
264impl ser::SerializeSeq for SerializeArray {
265    type Ok = Value;
266    type Error = Error;
267
268    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
269    where
270        T: ?Sized + ser::Serialize,
271    {
272        self.sequence.push(to_value(elem)?);
273        Ok(())
274    }
275
276    fn end(self) -> Result<Value> {
277        Ok(Value::Sequence(self.sequence))
278    }
279}
280
281impl ser::SerializeTuple for SerializeArray {
282    type Ok = Value;
283    type Error = Error;
284
285    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
286    where
287        T: ?Sized + ser::Serialize,
288    {
289        ser::SerializeSeq::serialize_element(self, elem)
290    }
291
292    fn end(self) -> Result<Value> {
293        ser::SerializeSeq::end(self)
294    }
295}
296
297impl ser::SerializeTupleStruct for SerializeArray {
298    type Ok = Value;
299    type Error = Error;
300
301    fn serialize_field<V>(&mut self, value: &V) -> Result<()>
302    where
303        V: ?Sized + ser::Serialize,
304    {
305        ser::SerializeSeq::serialize_element(self, value)
306    }
307
308    fn end(self) -> Result<Value> {
309        ser::SerializeSeq::end(self)
310    }
311}
312
313pub struct SerializeTupleVariant {
314    tag: &'static str,
315    sequence: Sequence,
316}
317
318impl ser::SerializeTupleVariant for SerializeTupleVariant {
319    type Ok = Value;
320    type Error = Error;
321
322    fn serialize_field<V>(&mut self, v: &V) -> Result<()>
323    where
324        V: ?Sized + ser::Serialize,
325    {
326        self.sequence.push(to_value(v)?);
327        Ok(())
328    }
329
330    fn end(self) -> Result<Value> {
331        Ok(Value::Tagged(Box::new(TaggedValue {
332            tag: Tag::new(self.tag),
333            value: Value::Sequence(self.sequence),
334        })))
335    }
336}
337
338pub enum SerializeMap {
339    CheckForTag,
340    Tagged(TaggedValue),
341    Untagged { mapping: Mapping, next_key: Option<Value> },
342}
343
344impl ser::SerializeMap for SerializeMap {
345    type Ok = Value;
346    type Error = Error;
347
348    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
349    where
350        T: ?Sized + ser::Serialize,
351    {
352        let key = Some(to_value(key)?);
353        match self {
354            SerializeMap::CheckForTag => {
355                *self = SerializeMap::Untagged {
356                    mapping: Mapping::new(),
357                    next_key: key,
358                };
359            }
360            SerializeMap::Tagged(tagged) => {
361                let mut mapping = Mapping::new();
362                mapping.insert(Value::String(tagged.tag.to_string()), mem::take(&mut tagged.value));
363                *self = SerializeMap::Untagged {
364                    mapping,
365                    next_key: key,
366                };
367            }
368            SerializeMap::Untagged {
369                next_key, ..
370            } => *next_key = key,
371        }
372        Ok(())
373    }
374
375    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
376    where
377        T: ?Sized + ser::Serialize,
378    {
379        let (mapping, key) = match self {
380            SerializeMap::CheckForTag | SerializeMap::Tagged(_) => unreachable!(),
381            SerializeMap::Untagged {
382                mapping,
383                next_key,
384            } => (mapping, next_key),
385        };
386        match key.take() {
387            Some(key) => mapping.insert(key, to_value(value)?),
388            None => panic!("serialize_value called before serialize_key"),
389        };
390        Ok(())
391    }
392
393    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
394    where
395        K: ?Sized + ser::Serialize,
396        V: ?Sized + ser::Serialize,
397    {
398        struct CheckForTag;
399        struct NotTag<T> {
400            delegate: T,
401        }
402
403        impl ser::Serializer for CheckForTag {
404            type Ok = MaybeTag<Value>;
405            type Error = Error;
406
407            type SerializeSeq = NotTag<SerializeArray>;
408            type SerializeTuple = NotTag<SerializeArray>;
409            type SerializeTupleStruct = NotTag<SerializeArray>;
410            type SerializeTupleVariant = NotTag<SerializeTupleVariant>;
411            type SerializeMap = NotTag<SerializeMap>;
412            type SerializeStruct = NotTag<SerializeStruct>;
413            type SerializeStructVariant = NotTag<SerializeStructVariant>;
414
415            fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
416                Serializer.serialize_bool(v).map(MaybeTag::NotTag)
417            }
418
419            fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
420                Serializer.serialize_i8(v).map(MaybeTag::NotTag)
421            }
422
423            fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
424                Serializer.serialize_i16(v).map(MaybeTag::NotTag)
425            }
426
427            fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
428                Serializer.serialize_i32(v).map(MaybeTag::NotTag)
429            }
430
431            fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
432                Serializer.serialize_i64(v).map(MaybeTag::NotTag)
433            }
434
435            fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
436                Serializer.serialize_i128(v).map(MaybeTag::NotTag)
437            }
438
439            fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
440                Serializer.serialize_u8(v).map(MaybeTag::NotTag)
441            }
442
443            fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
444                Serializer.serialize_u16(v).map(MaybeTag::NotTag)
445            }
446
447            fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
448                Serializer.serialize_u32(v).map(MaybeTag::NotTag)
449            }
450
451            fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
452                Serializer.serialize_u64(v).map(MaybeTag::NotTag)
453            }
454
455            fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
456                Serializer.serialize_u128(v).map(MaybeTag::NotTag)
457            }
458
459            fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
460                Serializer.serialize_f32(v).map(MaybeTag::NotTag)
461            }
462
463            fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
464                Serializer.serialize_f64(v).map(MaybeTag::NotTag)
465            }
466
467            fn serialize_char(self, value: char) -> Result<Self::Ok> {
468                Serializer.serialize_char(value).map(MaybeTag::NotTag)
469            }
470
471            fn serialize_str(self, value: &str) -> Result<Self::Ok> {
472                Serializer.serialize_str(value).map(MaybeTag::NotTag)
473            }
474
475            fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
476                Serializer.serialize_bytes(value).map(MaybeTag::NotTag)
477            }
478
479            fn serialize_unit(self) -> Result<Self::Ok> {
480                Serializer.serialize_unit().map(MaybeTag::NotTag)
481            }
482
483            fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
484                Serializer.serialize_unit_struct(name).map(MaybeTag::NotTag)
485            }
486
487            fn serialize_unit_variant(
488                self,
489                name: &'static str,
490                variant_index: u32,
491                variant: &'static str,
492            ) -> Result<Self::Ok> {
493                Serializer
494                    .serialize_unit_variant(name, variant_index, variant)
495                    .map(MaybeTag::NotTag)
496            }
497
498            fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Self::Ok>
499            where
500                T: ?Sized + ser::Serialize,
501            {
502                Serializer.serialize_newtype_struct(name, value).map(MaybeTag::NotTag)
503            }
504
505            fn serialize_newtype_variant<T>(
506                self,
507                name: &'static str,
508                variant_index: u32,
509                variant: &'static str,
510                value: &T,
511            ) -> Result<Self::Ok>
512            where
513                T: ?Sized + ser::Serialize,
514            {
515                Serializer
516                    .serialize_newtype_variant(name, variant_index, variant, value)
517                    .map(MaybeTag::NotTag)
518            }
519
520            fn serialize_none(self) -> Result<Self::Ok> {
521                Serializer.serialize_none().map(MaybeTag::NotTag)
522            }
523
524            fn serialize_some<V>(self, value: &V) -> Result<Self::Ok>
525            where
526                V: ?Sized + ser::Serialize,
527            {
528                Serializer.serialize_some(value).map(MaybeTag::NotTag)
529            }
530
531            fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
532                Ok(NotTag {
533                    delegate: Serializer.serialize_seq(len)?,
534                })
535            }
536
537            fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
538                Ok(NotTag {
539                    delegate: Serializer.serialize_tuple(len)?,
540                })
541            }
542
543            fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
544                Ok(NotTag {
545                    delegate: Serializer.serialize_tuple_struct(name, len)?,
546                })
547            }
548
549            fn serialize_tuple_variant(
550                self,
551                name: &'static str,
552                variant_index: u32,
553                variant: &'static str,
554                len: usize,
555            ) -> Result<Self::SerializeTupleVariant> {
556                Ok(NotTag {
557                    delegate: Serializer.serialize_tuple_variant(name, variant_index, variant, len)?,
558                })
559            }
560
561            fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
562                Ok(NotTag {
563                    delegate: Serializer.serialize_map(len)?,
564                })
565            }
566
567            fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
568                Ok(NotTag {
569                    delegate: Serializer.serialize_struct(name, len)?,
570                })
571            }
572
573            fn serialize_struct_variant(
574                self,
575                name: &'static str,
576                variant_index: u32,
577                variant: &'static str,
578                len: usize,
579            ) -> Result<Self::SerializeStructVariant> {
580                Ok(NotTag {
581                    delegate: Serializer.serialize_struct_variant(name, variant_index, variant, len)?,
582                })
583            }
584
585            fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
586            where
587                T: ?Sized + Display,
588            {
589                Ok(match tagged::check_for_tag(value) {
590                    MaybeTag::Tag(tag) => MaybeTag::Tag(tag),
591                    MaybeTag::NotTag(string) => MaybeTag::NotTag(Value::String(string)),
592                })
593            }
594        }
595
596        impl ser::SerializeSeq for NotTag<SerializeArray> {
597            type Ok = MaybeTag<Value>;
598            type Error = Error;
599
600            fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
601            where
602                T: ?Sized + ser::Serialize,
603            {
604                self.delegate.serialize_element(elem)
605            }
606
607            fn end(self) -> Result<Self::Ok> {
608                self.delegate.end().map(MaybeTag::NotTag)
609            }
610        }
611
612        impl ser::SerializeTuple for NotTag<SerializeArray> {
613            type Ok = MaybeTag<Value>;
614            type Error = Error;
615
616            fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
617            where
618                T: ?Sized + ser::Serialize,
619            {
620                self.delegate.serialize_element(elem)
621            }
622
623            fn end(self) -> Result<Self::Ok> {
624                self.delegate.end().map(MaybeTag::NotTag)
625            }
626        }
627
628        impl ser::SerializeTupleStruct for NotTag<SerializeArray> {
629            type Ok = MaybeTag<Value>;
630            type Error = Error;
631
632            fn serialize_field<V>(&mut self, value: &V) -> Result<()>
633            where
634                V: ?Sized + ser::Serialize,
635            {
636                self.delegate.serialize_field(value)
637            }
638
639            fn end(self) -> Result<Self::Ok> {
640                self.delegate.end().map(MaybeTag::NotTag)
641            }
642        }
643
644        impl ser::SerializeTupleVariant for NotTag<SerializeTupleVariant> {
645            type Ok = MaybeTag<Value>;
646            type Error = Error;
647
648            fn serialize_field<V>(&mut self, v: &V) -> Result<()>
649            where
650                V: ?Sized + ser::Serialize,
651            {
652                self.delegate.serialize_field(v)
653            }
654
655            fn end(self) -> Result<Self::Ok> {
656                self.delegate.end().map(MaybeTag::NotTag)
657            }
658        }
659
660        impl ser::SerializeMap for NotTag<SerializeMap> {
661            type Ok = MaybeTag<Value>;
662            type Error = Error;
663
664            fn serialize_key<T>(&mut self, key: &T) -> Result<()>
665            where
666                T: ?Sized + ser::Serialize,
667            {
668                self.delegate.serialize_key(key)
669            }
670
671            fn serialize_value<T>(&mut self, value: &T) -> Result<()>
672            where
673                T: ?Sized + ser::Serialize,
674            {
675                self.delegate.serialize_value(value)
676            }
677
678            fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
679            where
680                K: ?Sized + ser::Serialize,
681                V: ?Sized + ser::Serialize,
682            {
683                self.delegate.serialize_entry(key, value)
684            }
685
686            fn end(self) -> Result<Self::Ok> {
687                self.delegate.end().map(MaybeTag::NotTag)
688            }
689        }
690
691        impl ser::SerializeStruct for NotTag<SerializeStruct> {
692            type Ok = MaybeTag<Value>;
693            type Error = Error;
694
695            fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
696            where
697                V: ?Sized + ser::Serialize,
698            {
699                self.delegate.serialize_field(key, value)
700            }
701
702            fn end(self) -> Result<Self::Ok> {
703                self.delegate.end().map(MaybeTag::NotTag)
704            }
705        }
706
707        impl ser::SerializeStructVariant for NotTag<SerializeStructVariant> {
708            type Ok = MaybeTag<Value>;
709            type Error = Error;
710
711            fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
712            where
713                V: ?Sized + ser::Serialize,
714            {
715                self.delegate.serialize_field(field, v)
716            }
717
718            fn end(self) -> Result<Self::Ok> {
719                self.delegate.end().map(MaybeTag::NotTag)
720            }
721        }
722
723        match self {
724            SerializeMap::CheckForTag => {
725                let key = key.serialize(CheckForTag)?;
726                let mut mapping = Mapping::new();
727                *self = match key {
728                    MaybeTag::Tag(string) => SerializeMap::Tagged(TaggedValue {
729                        tag: Tag::new(string),
730                        value: to_value(value)?,
731                    }),
732                    MaybeTag::NotTag(key) => {
733                        mapping.insert(key, to_value(value)?);
734                        SerializeMap::Untagged {
735                            mapping,
736                            next_key: None,
737                        }
738                    }
739                };
740            }
741            SerializeMap::Tagged(tagged) => {
742                let mut mapping = Mapping::new();
743                mapping.insert(Value::String(tagged.tag.to_string()), mem::take(&mut tagged.value));
744                mapping.insert(to_value(key)?, to_value(value)?);
745                *self = SerializeMap::Untagged {
746                    mapping,
747                    next_key: None,
748                };
749            }
750            SerializeMap::Untagged {
751                mapping, ..
752            } => {
753                mapping.insert(to_value(key)?, to_value(value)?);
754            }
755        }
756        Ok(())
757    }
758
759    fn end(self) -> Result<Value> {
760        Ok(match self {
761            SerializeMap::CheckForTag => Value::Mapping(Mapping::new()),
762            SerializeMap::Tagged(tagged) => Value::Tagged(Box::new(tagged)),
763            SerializeMap::Untagged {
764                mapping, ..
765            } => Value::Mapping(mapping),
766        })
767    }
768}
769
770pub struct SerializeStruct {
771    mapping: Mapping,
772}
773
774impl ser::SerializeStruct for SerializeStruct {
775    type Ok = Value;
776    type Error = Error;
777
778    fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
779    where
780        V: ?Sized + ser::Serialize,
781    {
782        self.mapping.insert(to_value(key)?, to_value(value)?);
783        Ok(())
784    }
785
786    fn end(self) -> Result<Value> {
787        Ok(Value::Mapping(self.mapping))
788    }
789}
790
791pub struct SerializeStructVariant {
792    tag: &'static str,
793    mapping: Mapping,
794}
795
796impl ser::SerializeStructVariant for SerializeStructVariant {
797    type Ok = Value;
798    type Error = Error;
799
800    fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
801    where
802        V: ?Sized + ser::Serialize,
803    {
804        self.mapping.insert(to_value(field)?, to_value(v)?);
805        Ok(())
806    }
807
808    fn end(self) -> Result<Value> {
809        Ok(Value::Tagged(Box::new(TaggedValue {
810            tag: Tag::new(self.tag),
811            value: Value::Mapping(self.mapping),
812        })))
813    }
814}
serde_yaml/value/ser.rs

serde_yaml/value/
ser.rs
