serde_yaml/value/
ser.rs

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

serde_yaml/value/
ser.rs
