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