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