android/vendor/serde_yaml-0.8.24/src/ser.rs - toolchain/cargo-vet - Git at Google

 //! YAML Serialization
 //!
 //! This module provides YAML serialization with the type `Serializer`.

 use crate::{error, Error, Result};
 use serde::ser;
 use std::{fmt, io, num, str};
 use yaml_rust::{yaml, Yaml, YamlEmitter};

 /// A structure for serializing Rust values into YAML.
 ///
 /// # Example
 ///
 /// ```
 /// use anyhow::Result;
 /// use serde::Serialize;
 /// use std::collections::BTreeMap;
 ///
 /// fn main() -> Result<()> {
 ///     let mut buffer = Vec::new();
 ///     let mut ser = serde_yaml::Serializer::new(&mut buffer);
 ///
 ///     let mut object = BTreeMap::new();
 ///     object.insert("k", 107);
 ///     object.serialize(&mut ser)?;
 ///
 ///     object.insert("J", 74);
 ///     object.serialize(&mut ser)?;
 ///
 ///     assert_eq!(buffer, b"---\nk: 107\n...\n---\nJ: 74\nk: 107\n");
 ///     Ok(())
 /// }
 /// ```
 pub struct Serializer<W> {
     documents: usize,
     writer: W,
 }

 impl<W> Serializer<W>
 where
     W: io::Write,
 {
     /// Creates a new YAML serializer.
     pub fn new(writer: W) -> Self {
         Serializer {
             documents: 0,
             writer,
         }
     }

     /// Unwrap the underlying `io::Write` object from the `Serializer`.
     pub fn into_inner(self) -> W {
         self.writer
     }

     fn write(&mut self, doc: Yaml) -> Result<()> {
         if self.documents > 0 {
             self.writer.write_all(b"...\n").map_err(error::io)?;
         }
         self.documents += 1;
         let mut writer_adapter = FmtToIoWriter {
             writer: &mut self.writer,
         };
         YamlEmitter::new(&mut writer_adapter)
             .dump(&doc)
             .map_err(error::emitter)?;
         writer_adapter.writer.write_all(b"\n").map_err(error::io)?;
         Ok(())
     }
 }

 impl<'a, W> ser::Serializer for &'a mut Serializer<W>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     type SerializeSeq = ThenWrite<'a, W, SerializeArray>;
     type SerializeTuple = ThenWrite<'a, W, SerializeArray>;
     type SerializeTupleStruct = ThenWrite<'a, W, SerializeArray>;
     type SerializeTupleVariant = ThenWrite<'a, W, SerializeTupleVariant>;
     type SerializeMap = ThenWrite<'a, W, SerializeMap>;
     type SerializeStruct = ThenWrite<'a, W, SerializeStruct>;
     type SerializeStructVariant = ThenWrite<'a, W, SerializeStructVariant>;

     fn serialize_bool(self, v: bool) -> Result<()> {
         let doc = SerializerToYaml.serialize_bool(v)?;
         self.write(doc)
     }

     fn serialize_i8(self, v: i8) -> Result<()> {
         let doc = SerializerToYaml.serialize_i8(v)?;
         self.write(doc)
     }

     fn serialize_i16(self, v: i16) -> Result<()> {
         let doc = SerializerToYaml.serialize_i16(v)?;
         self.write(doc)
     }

     fn serialize_i32(self, v: i32) -> Result<()> {
         let doc = SerializerToYaml.serialize_i32(v)?;
         self.write(doc)
     }

     fn serialize_i64(self, v: i64) -> Result<()> {
         let doc = SerializerToYaml.serialize_i64(v)?;
         self.write(doc)
     }

     fn serialize_i128(self, v: i128) -> Result<()> {
         let doc = SerializerToYaml.serialize_i128(v)?;
         self.write(doc)
     }

     fn serialize_u8(self, v: u8) -> Result<()> {
         let doc = SerializerToYaml.serialize_u8(v)?;
         self.write(doc)
     }

     fn serialize_u16(self, v: u16) -> Result<()> {
         let doc = SerializerToYaml.serialize_u16(v)?;
         self.write(doc)
     }

     fn serialize_u32(self, v: u32) -> Result<()> {
         let doc = SerializerToYaml.serialize_u32(v)?;
         self.write(doc)
     }

     fn serialize_u64(self, v: u64) -> Result<()> {
         let doc = SerializerToYaml.serialize_u64(v)?;
         self.write(doc)
     }

     fn serialize_u128(self, v: u128) -> Result<()> {
         let doc = SerializerToYaml.serialize_u128(v)?;
         self.write(doc)
     }

     fn serialize_f32(self, v: f32) -> Result<()> {
         let doc = SerializerToYaml.serialize_f32(v)?;
         self.write(doc)
     }

     fn serialize_f64(self, v: f64) -> Result<()> {
         let doc = SerializerToYaml.serialize_f64(v)?;
         self.write(doc)
     }

     fn serialize_char(self, value: char) -> Result<()> {
         let doc = SerializerToYaml.serialize_char(value)?;
         self.write(doc)
     }

     fn serialize_str(self, value: &str) -> Result<()> {
         let doc = SerializerToYaml.serialize_str(value)?;
         self.write(doc)
     }

     fn serialize_bytes(self, value: &[u8]) -> Result<()> {
         let doc = SerializerToYaml.serialize_bytes(value)?;
         self.write(doc)
     }

     fn serialize_unit(self) -> Result<()> {
         let doc = SerializerToYaml.serialize_unit()?;
         self.write(doc)
     }

     fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
         let doc = SerializerToYaml.serialize_unit_struct(name)?;
         self.write(doc)
     }

     fn serialize_unit_variant(
         self,
         name: &'static str,
         variant_index: u32,
         variant: &'static str,
     ) -> Result<()> {
         let doc = SerializerToYaml.serialize_unit_variant(name, variant_index, variant)?;
         self.write(doc)
     }

     fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         let doc = SerializerToYaml.serialize_newtype_struct(name, value)?;
         self.write(doc)
     }

     fn serialize_newtype_variant<T>(
         self,
         name: &'static str,
         variant_index: u32,
         variant: &'static str,
         value: &T,
     ) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         let doc =
             SerializerToYaml.serialize_newtype_variant(name, variant_index, variant, value)?;
         self.write(doc)
     }

     fn serialize_none(self) -> Result<()> {
         let doc = SerializerToYaml.serialize_none()?;
         self.write(doc)
     }

     fn serialize_some<V>(self, value: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         let doc = SerializerToYaml.serialize_some(value)?;
         self.write(doc)
     }

     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
         let delegate = SerializerToYaml.serialize_seq(len)?;
         Ok(ThenWrite::new(self, delegate))
     }

     fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
         let delegate = SerializerToYaml.serialize_tuple(len)?;
         Ok(ThenWrite::new(self, delegate))
     }

     fn serialize_tuple_struct(
         self,
         name: &'static str,
         len: usize,
     ) -> Result<Self::SerializeTupleStruct> {
         let delegate = SerializerToYaml.serialize_tuple_struct(name, len)?;
         Ok(ThenWrite::new(self, delegate))
     }

     fn serialize_tuple_variant(
         self,
         enm: &'static str,
         idx: u32,
         variant: &'static str,
         len: usize,
     ) -> Result<Self::SerializeTupleVariant> {
         let delegate = SerializerToYaml.serialize_tuple_variant(enm, idx, variant, len)?;
         Ok(ThenWrite::new(self, delegate))
     }

     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
         let delegate = SerializerToYaml.serialize_map(len)?;
         Ok(ThenWrite::new(self, delegate))
     }

     fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
         let delegate = SerializerToYaml.serialize_struct(name, len)?;
         Ok(ThenWrite::new(self, delegate))
     }

     fn serialize_struct_variant(
         self,
         enm: &'static str,
         idx: u32,
         variant: &'static str,
         len: usize,
     ) -> Result<Self::SerializeStructVariant> {
         let delegate = SerializerToYaml.serialize_struct_variant(enm, idx, variant, len)?;
         Ok(ThenWrite::new(self, delegate))
     }
 }

 pub struct ThenWrite<'a, W, D> {
     serializer: &'a mut Serializer<W>,
     delegate: D,
 }

 impl<'a, W, D> ThenWrite<'a, W, D> {
     fn new(serializer: &'a mut Serializer<W>, delegate: D) -> Self {
         ThenWrite {
             serializer,
             delegate,
         }
     }
 }

 impl<'a, W> ser::SerializeSeq for ThenWrite<'a, W, SerializeArray>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_element(elem)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 impl<'a, W> ser::SerializeTuple for ThenWrite<'a, W, SerializeArray>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_element(elem)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 impl<'a, W> ser::SerializeTupleStruct for ThenWrite<'a, W, SerializeArray>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_field<V>(&mut self, value: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_field(value)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 impl<'a, W> ser::SerializeTupleVariant for ThenWrite<'a, W, SerializeTupleVariant>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_field<V>(&mut self, v: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_field(v)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 impl<'a, W> ser::SerializeMap for ThenWrite<'a, W, SerializeMap>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_key(key)
     }

     fn serialize_value<T>(&mut self, value: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_value(value)
     }

     fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
     where
         K: ?Sized + ser::Serialize,
         V: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_entry(key, value)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 impl<'a, W> ser::SerializeStruct for ThenWrite<'a, W, SerializeStruct>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_field(key, value)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 impl<'a, W> ser::SerializeStructVariant for ThenWrite<'a, W, SerializeStructVariant>
 where
     W: io::Write,
 {
     type Ok = ();
     type Error = Error;

     fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.delegate.serialize_field(field, v)
     }

     fn end(self) -> Result<()> {
         let doc = self.delegate.end()?;
         self.serializer.write(doc)
     }
 }

 pub struct SerializerToYaml;

 impl ser::Serializer for SerializerToYaml {
     type Ok = Yaml;
     type Error = Error;

     type SerializeSeq = SerializeArray;
     type SerializeTuple = SerializeArray;
     type SerializeTupleStruct = SerializeArray;
     type SerializeTupleVariant = SerializeTupleVariant;
     type SerializeMap = SerializeMap;
     type SerializeStruct = SerializeStruct;
     type SerializeStructVariant = SerializeStructVariant;

     fn serialize_bool(self, v: bool) -> Result<Yaml> {
         Ok(Yaml::Boolean(v))
     }

     fn serialize_i8(self, v: i8) -> Result<Yaml> {
         self.serialize_i64(v as i64)
     }

     fn serialize_i16(self, v: i16) -> Result<Yaml> {
         self.serialize_i64(v as i64)
     }

     fn serialize_i32(self, v: i32) -> Result<Yaml> {
         self.serialize_i64(v as i64)
     }

     fn serialize_i64(self, v: i64) -> Result<Yaml> {
         Ok(Yaml::Integer(v))
     }

     #[allow(clippy::cast_possible_truncation)]
     fn serialize_i128(self, v: i128) -> Result<Yaml> {
         if v <= i64::max_value() as i128 && v >= i64::min_value() as i128 {
             self.serialize_i64(v as i64)
         } else {
             Ok(Yaml::Real(v.to_string()))
         }
     }

     fn serialize_u8(self, v: u8) -> Result<Yaml> {
         self.serialize_i64(v as i64)
     }

     fn serialize_u16(self, v: u16) -> Result<Yaml> {
         self.serialize_i64(v as i64)
     }

     fn serialize_u32(self, v: u32) -> Result<Yaml> {
         self.serialize_i64(v as i64)
     }

     fn serialize_u64(self, v: u64) -> Result<Yaml> {
         if v <= i64::max_value() as u64 {
             self.serialize_i64(v as i64)
         } else {
             Ok(Yaml::Real(v.to_string()))
         }
     }

     #[allow(clippy::cast_possible_truncation)]
     fn serialize_u128(self, v: u128) -> Result<Yaml> {
         if v <= i64::max_value() as u128 {
             self.serialize_i64(v as i64)
         } else {
             Ok(Yaml::Real(v.to_string()))
         }
     }

     fn serialize_f32(self, v: f32) -> Result<Yaml> {
         Ok(Yaml::Real(match v.classify() {
             num::FpCategory::Infinite if v.is_sign_positive() => ".inf".into(),
             num::FpCategory::Infinite => "-.inf".into(),
             num::FpCategory::Nan => ".nan".into(),
             _ => ryu::Buffer::new().format_finite(v).into(),
         }))
     }

     fn serialize_f64(self, v: f64) -> Result<Yaml> {
         Ok(Yaml::Real(match v.classify() {
             num::FpCategory::Infinite if v.is_sign_positive() => ".inf".into(),
             num::FpCategory::Infinite => "-.inf".into(),
             num::FpCategory::Nan => ".nan".into(),
             _ => ryu::Buffer::new().format_finite(v).into(),
         }))
     }

     fn serialize_char(self, value: char) -> Result<Yaml> {
         Ok(Yaml::String(value.to_string()))
     }

     fn serialize_str(self, value: &str) -> Result<Yaml> {
         Ok(Yaml::String(value.to_owned()))
     }

     fn serialize_bytes(self, value: &[u8]) -> Result<Yaml> {
         let vec = value.iter().map(|&b| Yaml::Integer(b as i64)).collect();
         Ok(Yaml::Array(vec))
     }

     fn serialize_unit(self) -> Result<Yaml> {
         Ok(Yaml::Null)
     }

     fn serialize_unit_struct(self, _name: &'static str) -> Result<Yaml> {
         self.serialize_unit()
     }

     fn serialize_unit_variant(
         self,
         _name: &str,
         _variant_index: u32,
         variant: &str,
     ) -> Result<Yaml> {
         Ok(Yaml::String(variant.to_owned()))
     }

     fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Yaml>
     where
         T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }

     fn serialize_newtype_variant<T>(
         self,
         _name: &str,
         _variant_index: u32,
         variant: &str,
         value: &T,
     ) -> Result<Yaml>
     where
         T: ?Sized + ser::Serialize,
     {
         Ok(singleton_hash(to_yaml(variant)?, to_yaml(value)?))
     }

     fn serialize_none(self) -> Result<Yaml> {
         self.serialize_unit()
     }

     fn serialize_some<V>(self, value: &V) -> Result<Yaml>
     where
         V: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }

     fn serialize_seq(self, len: Option<usize>) -> Result<SerializeArray> {
         let array = match len {
             None => yaml::Array::new(),
             Some(len) => yaml::Array::with_capacity(len),
         };
         Ok(SerializeArray { array })
     }

     fn serialize_tuple(self, len: usize) -> Result<SerializeArray> {
         self.serialize_seq(Some(len))
     }

     fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<SerializeArray> {
         self.serialize_seq(Some(len))
     }

     fn serialize_tuple_variant(
         self,
         _enum: &'static str,
         _idx: u32,
         variant: &'static str,
         len: usize,
     ) -> Result<SerializeTupleVariant> {
         Ok(SerializeTupleVariant {
             name: variant,
             array: yaml::Array::with_capacity(len),
         })
     }

     fn serialize_map(self, _len: Option<usize>) -> Result<SerializeMap> {
         Ok(SerializeMap {
             hash: yaml::Hash::new(),
             next_key: None,
         })
     }

     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<SerializeStruct> {
         Ok(SerializeStruct {
             hash: yaml::Hash::new(),
         })
     }

     fn serialize_struct_variant(
         self,
         _enum: &'static str,
         _idx: u32,
         variant: &'static str,
         _len: usize,
     ) -> Result<SerializeStructVariant> {
         Ok(SerializeStructVariant {
             name: variant,
             hash: yaml::Hash::new(),
         })
     }
 }

 #[doc(hidden)]
 pub struct SerializeArray {
     array: yaml::Array,
 }

 #[doc(hidden)]
 pub struct SerializeTupleVariant {
     name: &'static str,
     array: yaml::Array,
 }

 #[doc(hidden)]
 pub struct SerializeMap {
     hash: yaml::Hash,
     next_key: Option<yaml::Yaml>,
 }

 #[doc(hidden)]
 pub struct SerializeStruct {
     hash: yaml::Hash,
 }

 #[doc(hidden)]
 pub struct SerializeStructVariant {
     name: &'static str,
     hash: yaml::Hash,
 }

 impl ser::SerializeSeq for SerializeArray {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         self.array.push(to_yaml(elem)?);
         Ok(())
     }

     fn end(self) -> Result<Yaml> {
         Ok(Yaml::Array(self.array))
     }
 }

 impl ser::SerializeTuple for SerializeArray {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, elem)
     }

     fn end(self) -> Result<Yaml> {
         ser::SerializeSeq::end(self)
     }
 }

 impl ser::SerializeTupleStruct for SerializeArray {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_field<V>(&mut self, value: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }

     fn end(self) -> Result<Yaml> {
         ser::SerializeSeq::end(self)
     }
 }

 impl ser::SerializeTupleVariant for SerializeTupleVariant {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_field<V>(&mut self, v: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.array.push(to_yaml(v)?);
         Ok(())
     }

     fn end(self) -> Result<Yaml> {
         Ok(singleton_hash(to_yaml(self.name)?, Yaml::Array(self.array)))
     }
 }

 impl ser::SerializeMap for SerializeMap {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         self.next_key = Some(to_yaml(key)?);
         Ok(())
     }

     fn serialize_value<T>(&mut self, value: &T) -> Result<()>
     where
         T: ?Sized + ser::Serialize,
     {
         match self.next_key.take() {
             Some(key) => self.hash.insert(key, to_yaml(value)?),
             None => panic!("serialize_value called before serialize_key"),
         };
         Ok(())
     }

     fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
     where
         K: ?Sized + ser::Serialize,
         V: ?Sized + ser::Serialize,
     {
         self.hash.insert(to_yaml(key)?, to_yaml(value)?);
         Ok(())
     }

     fn end(self) -> Result<Yaml> {
         Ok(Yaml::Hash(self.hash))
     }
 }

 impl ser::SerializeStruct for SerializeStruct {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.hash.insert(to_yaml(key)?, to_yaml(value)?);
         Ok(())
     }

     fn end(self) -> Result<Yaml> {
         Ok(Yaml::Hash(self.hash))
     }
 }

 impl ser::SerializeStructVariant for SerializeStructVariant {
     type Ok = yaml::Yaml;
     type Error = Error;

     fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
     where
         V: ?Sized + ser::Serialize,
     {
         self.hash.insert(to_yaml(field)?, to_yaml(v)?);
         Ok(())
     }

     fn end(self) -> Result<Yaml> {
         Ok(singleton_hash(to_yaml(self.name)?, Yaml::Hash(self.hash)))
     }
 }

 /// Serialize the given data structure as YAML into the IO stream.
 ///
 /// Serialization can fail if `T`'s implementation of `Serialize` decides to
 /// return an error.
 pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
 where
     W: io::Write,
     T: ?Sized + ser::Serialize,
 {
     value.serialize(&mut Serializer::new(writer))
 }

 /// Serialize the given data structure as a YAML byte vector.
 ///
 /// Serialization can fail if `T`'s implementation of `Serialize` decides to
 /// return an error.
 pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
 where
     T: ?Sized + ser::Serialize,
 {
     let mut vec = Vec::with_capacity(128);
     to_writer(&mut vec, value)?;
     Ok(vec)
 }

 /// Serialize the given data structure as a String of YAML.
 ///
 /// Serialization can fail if `T`'s implementation of `Serialize` decides to
 /// return an error.
 pub fn to_string<T>(value: &T) -> Result<String>
 where
     T: ?Sized + ser::Serialize,
 {
     String::from_utf8(to_vec(value)?).map_err(error::string_utf8)
 }

 /// The yaml-rust library uses `fmt::Write` intead of `io::Write` so this is a
 /// simple adapter.
 struct FmtToIoWriter<W> {
     writer: W,
 }

 impl<W> fmt::Write for FmtToIoWriter<W>
 where
     W: io::Write,
 {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         if self.writer.write_all(s.as_bytes()).is_err() {
             return Err(fmt::Error);
         }
         Ok(())
     }
 }

 fn to_yaml<T>(elem: T) -> Result<Yaml>
 where
     T: ser::Serialize,
 {
     elem.serialize(SerializerToYaml)
 }

 fn singleton_hash(k: Yaml, v: Yaml) -> Yaml {
     let mut hash = yaml::Hash::new();
     hash.insert(k, v);
     Yaml::Hash(hash)
 }
	//! YAML Serialization
	//!
	//! This module provides YAML serialization with the type `Serializer`.

	use crate::{error, Error, Result};
	use serde::ser;
	use std::{fmt, io, num, str};
	use yaml_rust::{yaml, Yaml, YamlEmitter};

	/// A structure for serializing Rust values into YAML.
	///
	/// # Example
	///
	/// ```
	/// use anyhow::Result;
	/// use serde::Serialize;
	/// use std::collections::BTreeMap;
	///
	/// fn main() -> Result<()> {
	/// let mut buffer = Vec::new();
	/// let mut ser = serde_yaml::Serializer::new(&mut buffer);
	///
	/// let mut object = BTreeMap::new();
	/// object.insert("k", 107);
	/// object.serialize(&mut ser)?;
	///
	/// object.insert("J", 74);
	/// object.serialize(&mut ser)?;
	///
	/// assert_eq!(buffer, b"---\nk: 107\n...\n---\nJ: 74\nk: 107\n");
	/// Ok(())
	/// }
	/// ```
	pub struct Serializer<W> {
	documents: usize,
	writer: W,
	}

	impl<W> Serializer<W>
	where
	W: io::Write,
	{
	/// Creates a new YAML serializer.
	pub fn new(writer: W) -> Self {
	Serializer {
	documents: 0,
	writer,
	}
	}

	/// Unwrap the underlying `io::Write` object from the `Serializer`.
	pub fn into_inner(self) -> W {
	self.writer
	}

	fn write(&mut self, doc: Yaml) -> Result<()> {
	if self.documents > 0 {
	self.writer.write_all(b"...\n").map_err(error::io)?;
	}
	self.documents += 1;
	let mut writer_adapter = FmtToIoWriter {
	writer: &mut self.writer,
	};
	YamlEmitter::new(&mut writer_adapter)
	.dump(&doc)
	.map_err(error::emitter)?;
	writer_adapter.writer.write_all(b"\n").map_err(error::io)?;
	Ok(())
	}
	}

	impl<'a, W> ser::Serializer for &'a mut Serializer<W>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	type SerializeSeq = ThenWrite<'a, W, SerializeArray>;
	type SerializeTuple = ThenWrite<'a, W, SerializeArray>;
	type SerializeTupleStruct = ThenWrite<'a, W, SerializeArray>;
	type SerializeTupleVariant = ThenWrite<'a, W, SerializeTupleVariant>;
	type SerializeMap = ThenWrite<'a, W, SerializeMap>;
	type SerializeStruct = ThenWrite<'a, W, SerializeStruct>;
	type SerializeStructVariant = ThenWrite<'a, W, SerializeStructVariant>;

	fn serialize_bool(self, v: bool) -> Result<()> {
	let doc = SerializerToYaml.serialize_bool(v)?;
	self.write(doc)
	}

	fn serialize_i8(self, v: i8) -> Result<()> {
	let doc = SerializerToYaml.serialize_i8(v)?;
	self.write(doc)
	}

	fn serialize_i16(self, v: i16) -> Result<()> {
	let doc = SerializerToYaml.serialize_i16(v)?;
	self.write(doc)
	}

	fn serialize_i32(self, v: i32) -> Result<()> {
	let doc = SerializerToYaml.serialize_i32(v)?;
	self.write(doc)
	}

	fn serialize_i64(self, v: i64) -> Result<()> {
	let doc = SerializerToYaml.serialize_i64(v)?;
	self.write(doc)
	}

	fn serialize_i128(self, v: i128) -> Result<()> {
	let doc = SerializerToYaml.serialize_i128(v)?;
	self.write(doc)
	}

	fn serialize_u8(self, v: u8) -> Result<()> {
	let doc = SerializerToYaml.serialize_u8(v)?;
	self.write(doc)
	}

	fn serialize_u16(self, v: u16) -> Result<()> {
	let doc = SerializerToYaml.serialize_u16(v)?;
	self.write(doc)
	}

	fn serialize_u32(self, v: u32) -> Result<()> {
	let doc = SerializerToYaml.serialize_u32(v)?;
	self.write(doc)
	}

	fn serialize_u64(self, v: u64) -> Result<()> {
	let doc = SerializerToYaml.serialize_u64(v)?;
	self.write(doc)
	}

	fn serialize_u128(self, v: u128) -> Result<()> {
	let doc = SerializerToYaml.serialize_u128(v)?;
	self.write(doc)
	}

	fn serialize_f32(self, v: f32) -> Result<()> {
	let doc = SerializerToYaml.serialize_f32(v)?;
	self.write(doc)
	}

	fn serialize_f64(self, v: f64) -> Result<()> {
	let doc = SerializerToYaml.serialize_f64(v)?;
	self.write(doc)
	}

	fn serialize_char(self, value: char) -> Result<()> {
	let doc = SerializerToYaml.serialize_char(value)?;
	self.write(doc)
	}

	fn serialize_str(self, value: &str) -> Result<()> {
	let doc = SerializerToYaml.serialize_str(value)?;
	self.write(doc)
	}

	fn serialize_bytes(self, value: &[u8]) -> Result<()> {
	let doc = SerializerToYaml.serialize_bytes(value)?;
	self.write(doc)
	}

	fn serialize_unit(self) -> Result<()> {
	let doc = SerializerToYaml.serialize_unit()?;
	self.write(doc)
	}

	fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
	let doc = SerializerToYaml.serialize_unit_struct(name)?;
	self.write(doc)
	}

	fn serialize_unit_variant(
	self,
	name: &'static str,
	variant_index: u32,
	variant: &'static str,
	) -> Result<()> {
	let doc = SerializerToYaml.serialize_unit_variant(name, variant_index, variant)?;
	self.write(doc)
	}

	fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	let doc = SerializerToYaml.serialize_newtype_struct(name, value)?;
	self.write(doc)
	}

	fn serialize_newtype_variant<T>(
	self,
	name: &'static str,
	variant_index: u32,
	variant: &'static str,
	value: &T,
	) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	let doc =
	SerializerToYaml.serialize_newtype_variant(name, variant_index, variant, value)?;
	self.write(doc)
	}

	fn serialize_none(self) -> Result<()> {
	let doc = SerializerToYaml.serialize_none()?;
	self.write(doc)
	}

	fn serialize_some<V>(self, value: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	let doc = SerializerToYaml.serialize_some(value)?;
	self.write(doc)
	}

	fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
	let delegate = SerializerToYaml.serialize_seq(len)?;
	Ok(ThenWrite::new(self, delegate))
	}

	fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
	let delegate = SerializerToYaml.serialize_tuple(len)?;
	Ok(ThenWrite::new(self, delegate))
	}

	fn serialize_tuple_struct(
	self,
	name: &'static str,
	len: usize,
	) -> Result<Self::SerializeTupleStruct> {
	let delegate = SerializerToYaml.serialize_tuple_struct(name, len)?;
	Ok(ThenWrite::new(self, delegate))
	}

	fn serialize_tuple_variant(
	self,
	enm: &'static str,
	idx: u32,
	variant: &'static str,
	len: usize,
	) -> Result<Self::SerializeTupleVariant> {
	let delegate = SerializerToYaml.serialize_tuple_variant(enm, idx, variant, len)?;
	Ok(ThenWrite::new(self, delegate))
	}

	fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
	let delegate = SerializerToYaml.serialize_map(len)?;
	Ok(ThenWrite::new(self, delegate))
	}

	fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
	let delegate = SerializerToYaml.serialize_struct(name, len)?;
	Ok(ThenWrite::new(self, delegate))
	}

	fn serialize_struct_variant(
	self,
	enm: &'static str,
	idx: u32,
	variant: &'static str,
	len: usize,
	) -> Result<Self::SerializeStructVariant> {
	let delegate = SerializerToYaml.serialize_struct_variant(enm, idx, variant, len)?;
	Ok(ThenWrite::new(self, delegate))
	}
	}

	pub struct ThenWrite<'a, W, D> {
	serializer: &'a mut Serializer<W>,
	delegate: D,
	}

	impl<'a, W, D> ThenWrite<'a, W, D> {
	fn new(serializer: &'a mut Serializer<W>, delegate: D) -> Self {
	ThenWrite {
	serializer,
	delegate,
	}
	}
	}

	impl<'a, W> ser::SerializeSeq for ThenWrite<'a, W, SerializeArray>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_element(elem)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	impl<'a, W> ser::SerializeTuple for ThenWrite<'a, W, SerializeArray>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_element(elem)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	impl<'a, W> ser::SerializeTupleStruct for ThenWrite<'a, W, SerializeArray>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_field<V>(&mut self, value: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_field(value)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	impl<'a, W> ser::SerializeTupleVariant for ThenWrite<'a, W, SerializeTupleVariant>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_field<V>(&mut self, v: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_field(v)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	impl<'a, W> ser::SerializeMap for ThenWrite<'a, W, SerializeMap>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_key<T>(&mut self, key: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_key(key)
	}

	fn serialize_value<T>(&mut self, value: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_value(value)
	}

	fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
	where
	K: ?Sized + ser::Serialize,
	V: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_entry(key, value)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	impl<'a, W> ser::SerializeStruct for ThenWrite<'a, W, SerializeStruct>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_field(key, value)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	impl<'a, W> ser::SerializeStructVariant for ThenWrite<'a, W, SerializeStructVariant>
	where
	W: io::Write,
	{
	type Ok = ();
	type Error = Error;

	fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.delegate.serialize_field(field, v)
	}

	fn end(self) -> Result<()> {
	let doc = self.delegate.end()?;
	self.serializer.write(doc)
	}
	}

	pub struct SerializerToYaml;

	impl ser::Serializer for SerializerToYaml {
	type Ok = Yaml;
	type Error = Error;

	type SerializeSeq = SerializeArray;
	type SerializeTuple = SerializeArray;
	type SerializeTupleStruct = SerializeArray;
	type SerializeTupleVariant = SerializeTupleVariant;
	type SerializeMap = SerializeMap;
	type SerializeStruct = SerializeStruct;
	type SerializeStructVariant = SerializeStructVariant;

	fn serialize_bool(self, v: bool) -> Result<Yaml> {
	Ok(Yaml::Boolean(v))
	}

	fn serialize_i8(self, v: i8) -> Result<Yaml> {
	self.serialize_i64(v as i64)
	}

	fn serialize_i16(self, v: i16) -> Result<Yaml> {
	self.serialize_i64(v as i64)
	}

	fn serialize_i32(self, v: i32) -> Result<Yaml> {
	self.serialize_i64(v as i64)
	}

	fn serialize_i64(self, v: i64) -> Result<Yaml> {
	Ok(Yaml::Integer(v))
	}

	#[allow(clippy::cast_possible_truncation)]
	fn serialize_i128(self, v: i128) -> Result<Yaml> {
	if v <= i64::max_value() as i128 && v >= i64::min_value() as i128 {
	self.serialize_i64(v as i64)
	} else {
	Ok(Yaml::Real(v.to_string()))
	}
	}

	fn serialize_u8(self, v: u8) -> Result<Yaml> {
	self.serialize_i64(v as i64)
	}

	fn serialize_u16(self, v: u16) -> Result<Yaml> {
	self.serialize_i64(v as i64)
	}

	fn serialize_u32(self, v: u32) -> Result<Yaml> {
	self.serialize_i64(v as i64)
	}

	fn serialize_u64(self, v: u64) -> Result<Yaml> {
	if v <= i64::max_value() as u64 {
	self.serialize_i64(v as i64)
	} else {
	Ok(Yaml::Real(v.to_string()))
	}
	}

	#[allow(clippy::cast_possible_truncation)]
	fn serialize_u128(self, v: u128) -> Result<Yaml> {
	if v <= i64::max_value() as u128 {
	self.serialize_i64(v as i64)
	} else {
	Ok(Yaml::Real(v.to_string()))
	}
	}

	fn serialize_f32(self, v: f32) -> Result<Yaml> {
	Ok(Yaml::Real(match v.classify() {
	num::FpCategory::Infinite if v.is_sign_positive() => ".inf".into(),
	num::FpCategory::Infinite => "-.inf".into(),
	num::FpCategory::Nan => ".nan".into(),
	_ => ryu::Buffer::new().format_finite(v).into(),
	}))
	}

	fn serialize_f64(self, v: f64) -> Result<Yaml> {
	Ok(Yaml::Real(match v.classify() {
	num::FpCategory::Infinite if v.is_sign_positive() => ".inf".into(),
	num::FpCategory::Infinite => "-.inf".into(),
	num::FpCategory::Nan => ".nan".into(),
	_ => ryu::Buffer::new().format_finite(v).into(),
	}))
	}

	fn serialize_char(self, value: char) -> Result<Yaml> {
	Ok(Yaml::String(value.to_string()))
	}

	fn serialize_str(self, value: &str) -> Result<Yaml> {
	Ok(Yaml::String(value.to_owned()))
	}

	fn serialize_bytes(self, value: &[u8]) -> Result<Yaml> {
	let vec = value.iter().map(\|&b\| Yaml::Integer(b as i64)).collect();
	Ok(Yaml::Array(vec))
	}

	fn serialize_unit(self) -> Result<Yaml> {
	Ok(Yaml::Null)
	}

	fn serialize_unit_struct(self, _name: &'static str) -> Result<Yaml> {
	self.serialize_unit()
	}

	fn serialize_unit_variant(
	self,
	_name: &str,
	_variant_index: u32,
	variant: &str,
	) -> Result<Yaml> {
	Ok(Yaml::String(variant.to_owned()))
	}

	fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Yaml>
	where
	T: ?Sized + ser::Serialize,
	{
	value.serialize(self)
	}

	fn serialize_newtype_variant<T>(
	self,
	_name: &str,
	_variant_index: u32,
	variant: &str,
	value: &T,
	) -> Result<Yaml>
	where
	T: ?Sized + ser::Serialize,
	{
	Ok(singleton_hash(to_yaml(variant)?, to_yaml(value)?))
	}

	fn serialize_none(self) -> Result<Yaml> {
	self.serialize_unit()
	}

	fn serialize_some<V>(self, value: &V) -> Result<Yaml>
	where
	V: ?Sized + ser::Serialize,
	{
	value.serialize(self)
	}

	fn serialize_seq(self, len: Option<usize>) -> Result<SerializeArray> {
	let array = match len {
	None => yaml::Array::new(),
	Some(len) => yaml::Array::with_capacity(len),
	};
	Ok(SerializeArray { array })
	}

	fn serialize_tuple(self, len: usize) -> Result<SerializeArray> {
	self.serialize_seq(Some(len))
	}

	fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<SerializeArray> {
	self.serialize_seq(Some(len))
	}

	fn serialize_tuple_variant(
	self,
	_enum: &'static str,
	_idx: u32,
	variant: &'static str,
	len: usize,
	) -> Result<SerializeTupleVariant> {
	Ok(SerializeTupleVariant {
	name: variant,
	array: yaml::Array::with_capacity(len),
	})
	}

	fn serialize_map(self, _len: Option<usize>) -> Result<SerializeMap> {
	Ok(SerializeMap {
	hash: yaml::Hash::new(),
	next_key: None,
	})
	}

	fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<SerializeStruct> {
	Ok(SerializeStruct {
	hash: yaml::Hash::new(),
	})
	}

	fn serialize_struct_variant(
	self,
	_enum: &'static str,
	_idx: u32,
	variant: &'static str,
	_len: usize,
	) -> Result<SerializeStructVariant> {
	Ok(SerializeStructVariant {
	name: variant,
	hash: yaml::Hash::new(),
	})
	}
	}

	#[doc(hidden)]
	pub struct SerializeArray {
	array: yaml::Array,
	}

	#[doc(hidden)]
	pub struct SerializeTupleVariant {
	name: &'static str,
	array: yaml::Array,
	}

	#[doc(hidden)]
	pub struct SerializeMap {
	hash: yaml::Hash,
	next_key: Option<yaml::Yaml>,
	}

	#[doc(hidden)]
	pub struct SerializeStruct {
	hash: yaml::Hash,
	}

	#[doc(hidden)]
	pub struct SerializeStructVariant {
	name: &'static str,
	hash: yaml::Hash,
	}

	impl ser::SerializeSeq for SerializeArray {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	self.array.push(to_yaml(elem)?);
	Ok(())
	}

	fn end(self) -> Result<Yaml> {
	Ok(Yaml::Array(self.array))
	}
	}

	impl ser::SerializeTuple for SerializeArray {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	ser::SerializeSeq::serialize_element(self, elem)
	}

	fn end(self) -> Result<Yaml> {
	ser::SerializeSeq::end(self)
	}
	}

	impl ser::SerializeTupleStruct for SerializeArray {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_field<V>(&mut self, value: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	ser::SerializeSeq::serialize_element(self, value)
	}

	fn end(self) -> Result<Yaml> {
	ser::SerializeSeq::end(self)
	}
	}

	impl ser::SerializeTupleVariant for SerializeTupleVariant {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_field<V>(&mut self, v: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.array.push(to_yaml(v)?);
	Ok(())
	}

	fn end(self) -> Result<Yaml> {
	Ok(singleton_hash(to_yaml(self.name)?, Yaml::Array(self.array)))
	}
	}

	impl ser::SerializeMap for SerializeMap {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_key<T>(&mut self, key: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	self.next_key = Some(to_yaml(key)?);
	Ok(())
	}

	fn serialize_value<T>(&mut self, value: &T) -> Result<()>
	where
	T: ?Sized + ser::Serialize,
	{
	match self.next_key.take() {
	Some(key) => self.hash.insert(key, to_yaml(value)?),
	None => panic!("serialize_value called before serialize_key"),
	};
	Ok(())
	}

	fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
	where
	K: ?Sized + ser::Serialize,
	V: ?Sized + ser::Serialize,
	{
	self.hash.insert(to_yaml(key)?, to_yaml(value)?);
	Ok(())
	}

	fn end(self) -> Result<Yaml> {
	Ok(Yaml::Hash(self.hash))
	}
	}

	impl ser::SerializeStruct for SerializeStruct {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.hash.insert(to_yaml(key)?, to_yaml(value)?);
	Ok(())
	}

	fn end(self) -> Result<Yaml> {
	Ok(Yaml::Hash(self.hash))
	}
	}

	impl ser::SerializeStructVariant for SerializeStructVariant {
	type Ok = yaml::Yaml;
	type Error = Error;

	fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
	where
	V: ?Sized + ser::Serialize,
	{
	self.hash.insert(to_yaml(field)?, to_yaml(v)?);
	Ok(())
	}

	fn end(self) -> Result<Yaml> {
	Ok(singleton_hash(to_yaml(self.name)?, Yaml::Hash(self.hash)))
	}
	}

	/// Serialize the given data structure as YAML into the IO stream.
	///
	/// Serialization can fail if `T`'s implementation of `Serialize` decides to
	/// return an error.
	pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
	where
	W: io::Write,
	T: ?Sized + ser::Serialize,
	{
	value.serialize(&mut Serializer::new(writer))
	}

	/// Serialize the given data structure as a YAML byte vector.
	///
	/// Serialization can fail if `T`'s implementation of `Serialize` decides to
	/// return an error.
	pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
	where
	T: ?Sized + ser::Serialize,
	{
	let mut vec = Vec::with_capacity(128);
	to_writer(&mut vec, value)?;
	Ok(vec)
	}

	/// Serialize the given data structure as a String of YAML.
	///
	/// Serialization can fail if `T`'s implementation of `Serialize` decides to
	/// return an error.
	pub fn to_string<T>(value: &T) -> Result<String>
	where
	T: ?Sized + ser::Serialize,
	{
	String::from_utf8(to_vec(value)?).map_err(error::string_utf8)
	}

	/// The yaml-rust library uses `fmt::Write` intead of `io::Write` so this is a
	/// simple adapter.
	struct FmtToIoWriter<W> {
	writer: W,
	}

	impl<W> fmt::Write for FmtToIoWriter<W>
	where
	W: io::Write,
	{
	fn write_str(&mut self, s: &str) -> fmt::Result {
	if self.writer.write_all(s.as_bytes()).is_err() {
	return Err(fmt::Error);
	}
	Ok(())
	}
	}

	fn to_yaml<T>(elem: T) -> Result<Yaml>
	where
	T: ser::Serialize,
	{
	elem.serialize(SerializerToYaml)
	}

	fn singleton_hash(k: Yaml, v: Yaml) -> Yaml {
	let mut hash = yaml::Hash::new();
	hash.insert(k, v);
	Yaml::Hash(hash)
	}