Quelle  ser.rs

use crate::error::{self, Error, ErrorImpl};
use crate::value::tagged::{self, MaybeTag};
use crate::value::{to_value, Mapping, Number, Sequence, Tag, TaggedValue, Value};
use serde::ser::{self, Serialize};
use std::fmt::Display;
use std::mem;

type Result<T, E = Error> = std::result::Result<T, E>;

impl Serialize for Value {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Value::Null => serializer.serialize_unit(),
            Value::Bool(b) => serializer.serialize_bool(*b),
            Value::Number(n) => n.serialize(serializer),
            Value::String(s) => serializer.serialize_str(s),
            Value::Sequence(seq) => seq.serialize(serializer),
            Value::Mapping(mapping) => {
                use serde::ser::SerializeMap;
                let mut map = serializer.serialize_map(Some(mapping.len()))?;
                for (k, v) in mapping {
                    map.serialize_entry(k, v)?;
                }
                map.end()
            }
            Value::Tagged(tagged) => tagged.serialize(serializer),
        }
    }
}

/// Serializer whose output is a `Value`.
///
/// This is the serializer that backs [`serde_yaml::to_value`][crate::to_value].
/// Unlike the main serde_yaml serializer which goes from some serializable
/// value of type `T` to YAML text, this one goes from `T` to
/// `serde_yaml::Value`.
///
/// The `to_value` function is implementable as:
///
/// ```
/// use serde::Serialize;
/// use serde_yaml::{Error, Value};
///
/// pub fn to_value<T>(input: T) -> Result<Value, Error>
/// where
///     T: Serialize,
/// {
///     input.serialize(serde_yaml::value::Serializer)
/// }
/// ```
pub struct Serializer;

impl ser::Serializer for Serializer {
    type Ok = Value;
    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<Value> {
        Ok(Value::Bool(v))
    }

    fn serialize_i8(self, v: i8) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_i16(self, v: i16) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_i32(self, v: i32) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_i64(self, v: i64) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_i128(self, v: i128) -> Result<Value> {
        if let Ok(v) = u64::try_from(v) {
            self.serialize_u64(v)
        } else if let Ok(v) = i64::try_from(v) {
            self.serialize_i64(v)
        } else {
            Ok(Value::String(v.to_string()))
        }
    }

    fn serialize_u8(self, v: u8) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_u16(self, v: u16) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_u32(self, v: u32) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_u64(self, v: u64) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_u128(self, v: u128) -> Result<Value> {
        if let Ok(v) = u64::try_from(v) {
            self.serialize_u64(v)
        } else {
            Ok(Value::String(v.to_string()))
        }
    }

    fn serialize_f32(self, v: f32) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

    fn serialize_f64(self, v: f64) -> Result<Value> {
        Ok(Value::Number(Number::from(v)))
    }

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

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

    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
        let vec = value
            .iter()
            .map(|&b| Value::Number(Number::from(b)))
            .collect();
        Ok(Value::Sequence(vec))
    }

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

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

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

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

    fn serialize_newtype_variant<T>(
        self,
        _name: &str,
        _variant_index: u32,
        variant: &str,
        value: &T,
    ) -> Result<Value>
    where
        T: ?Sized + ser::Serialize,
    {
        if variant.is_empty() {
            return Err(error::new(ErrorImpl::EmptyTag));
        }
        Ok(Value::Tagged(Box::new(TaggedValue {
            tag: Tag::new(variant),
            value: to_value(value)?,
        })))
    }

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

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

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

    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> {
        if variant.is_empty() {
            return Err(error::new(ErrorImpl::EmptyTag));
        }
        Ok(SerializeTupleVariant {
            tag: variant,
            sequence: Sequence::with_capacity(len),
        })
    }

    fn serialize_map(self, len: Option<usize>) -> Result<SerializeMap> {
        if len == Some(1) {
            Ok(SerializeMap::CheckForTag)
        } else {
            Ok(SerializeMap::Untagged {
                mapping: Mapping::new(),
                next_key: None,
            })
        }
    }

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

    fn serialize_struct_variant(
        self,
        _enum: &'static str,
        _idx: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<SerializeStructVariant> {
        if variant.is_empty() {
            return Err(error::new(ErrorImpl::EmptyTag));
        }
        Ok(SerializeStructVariant {
            tag: variant,
            mapping: Mapping::new(),
        })
    }
}

pub struct SerializeArray {
    sequence: Sequence,
}

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

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

    fn end(self) -> Result<Value> {
        Ok(Value::Sequence(self.sequence))
    }
}

impl ser::SerializeTuple for SerializeArray {
    type Ok = Value;
    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<Value> {
        ser::SerializeSeq::end(self)
    }
}

impl ser::SerializeTupleStruct for SerializeArray {
    type Ok = Value;
    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<Value> {
        ser::SerializeSeq::end(self)
    }
}

pub struct SerializeTupleVariant {
    tag: &'static str,
    sequence: Sequence,
}

impl ser::SerializeTupleVariant for SerializeTupleVariant {
    type Ok = Value;
    type Error = Error;

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

    fn end(self) -> Result<Value> {
        Ok(Value::Tagged(Box::new(TaggedValue {
            tag: Tag::new(self.tag),
            value: Value::Sequence(self.sequence),
        })))
    }
}

pub enum SerializeMap {
    CheckForTag,
    Tagged(TaggedValue),
    Untagged {
        mapping: Mapping,
        next_key: Option<Value>,
    },
}

impl ser::SerializeMap for SerializeMap {
    type Ok = Value;
    type Error = Error;

    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
    where
        T: ?Sized + ser::Serialize,
    {
        let key = Some(to_value(key)?);
        match self {
            SerializeMap::CheckForTag => {
                *self = SerializeMap::Untagged {
                    mapping: Mapping::new(),
                    next_key: key,
                };
            }
            SerializeMap::Tagged(tagged) => {
                let mut mapping = Mapping::new();
                mapping.insert(
                    Value::String(tagged.tag.to_string()),
                    mem::take(&mut tagged.value),
                );
                *self = SerializeMap::Untagged {
                    mapping,
                    next_key: key,
                };
            }
            SerializeMap::Untagged { next_key, .. } => *next_key = key,
        }
        Ok(())
    }

    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
    where
        T: ?Sized + ser::Serialize,
    {
        let (mapping, key) = match self {
            SerializeMap::CheckForTag | SerializeMap::Tagged(_) => unreachable!(),
            SerializeMap::Untagged { mapping, next_key } => (mapping, next_key),
        };
        match key.take() {
            Some(key) => mapping.insert(key, to_value(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,
    {
        struct CheckForTag;
        struct NotTag<T> {
            delegate: T,
        }

        impl ser::Serializer for CheckForTag {
            type Ok = MaybeTag<Value>;
            type Error = Error;

            type SerializeSeq = NotTag<SerializeArray>;
            type SerializeTuple = NotTag<SerializeArray>;
            type SerializeTupleStruct = NotTag<SerializeArray>;
            type SerializeTupleVariant = NotTag<SerializeTupleVariant>;
            type SerializeMap = NotTag<SerializeMap>;
            type SerializeStruct = NotTag<SerializeStruct>;
            type SerializeStructVariant = NotTag<SerializeStructVariant>;

            fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
                Serializer.serialize_bool(v).map(MaybeTag::NotTag)
            }

            fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
                Serializer.serialize_i8(v).map(MaybeTag::NotTag)
            }

            fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
                Serializer.serialize_i16(v).map(MaybeTag::NotTag)
            }

            fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
                Serializer.serialize_i32(v).map(MaybeTag::NotTag)
            }

            fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
                Serializer.serialize_i64(v).map(MaybeTag::NotTag)
            }

            fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
                Serializer.serialize_i128(v).map(MaybeTag::NotTag)
            }

            fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
                Serializer.serialize_u8(v).map(MaybeTag::NotTag)
            }

            fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
                Serializer.serialize_u16(v).map(MaybeTag::NotTag)
            }

            fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
                Serializer.serialize_u32(v).map(MaybeTag::NotTag)
            }

            fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
                Serializer.serialize_u64(v).map(MaybeTag::NotTag)
            }

            fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
                Serializer.serialize_u128(v).map(MaybeTag::NotTag)
            }

            fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
                Serializer.serialize_f32(v).map(MaybeTag::NotTag)
            }

            fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
                Serializer.serialize_f64(v).map(MaybeTag::NotTag)
            }

            fn serialize_char(self, value: char) -> Result<Self::Ok> {
                Serializer.serialize_char(value).map(MaybeTag::NotTag)
            }

            fn serialize_str(self, value: &str) -> Result<Self::Ok> {
                Serializer.serialize_str(value).map(MaybeTag::NotTag)
            }

            fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
                Serializer.serialize_bytes(value).map(MaybeTag::NotTag)
            }

            fn serialize_unit(self) -> Result<Self::Ok> {
                Serializer.serialize_unit().map(MaybeTag::NotTag)
            }

            fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
                Serializer.serialize_unit_struct(name).map(MaybeTag::NotTag)
            }

            fn serialize_unit_variant(
                self,
                name: &'static str,
                variant_index: u32,
                variant: &'static str,
            ) -> Result<Self::Ok> {
                Serializer
                    .serialize_unit_variant(name, variant_index, variant)
                    .map(MaybeTag::NotTag)
            }

            fn serialize_newtype_struct<T>(self, name: &'static str, value: &T)&nbsp;-> Result<Self::Ok>
            where
                T: ?Sized + ser::Serialize,
            {
                Serializer
                    .serialize_newtype_struct(name, value)
                    .map(MaybeTag::NotTag)
            }

            fn serialize_newtype_variant<T>(
                self,
                name: &'static str,
                variant_index: u32,
                variant: &'static str,
                value: &T,
            ) -> Result<Self::Ok>
            where
                T: ?Sized + ser::Serialize,
            {
                Serializer
                    .serialize_newtype_variant(name, variant_index, variant, value)
                    .map(MaybeTag::NotTag)
            }

            fn serialize_none(self) -> Result<Self::Ok> {
                Serializer.serialize_none().map(MaybeTag::NotTag)
            }

            fn serialize_some<V>(self, value: &V) -> Result<Self::Ok>
            where
                V: ?Sized + ser::Serialize,
            {
                Serializer.serialize_some(value).map(MaybeTag::NotTag)
            }

            fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
                Ok(NotTag {
                    delegate: Serializer.serialize_seq(len)?,
                })
            }

            fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
                Ok(NotTag {
                    delegate: Serializer.serialize_tuple(len)?,
                })
            }

            fn serialize_tuple_struct(
                self,
                name: &'static str,
                len: usize,
            ) -> Result<Self::SerializeTupleStruct> {
                Ok(NotTag {
                    delegate: Serializer.serialize_tuple_struct(name, len)?,
                })
            }

            fn serialize_tuple_variant(
                self,
                name: &'static str,
                variant_index: u32,
                variant: &'static str,
                len: usize,
            ) -> Result<Self::SerializeTupleVariant> {
                Ok(NotTag {
                    delegate: Serializer.serialize_tuple_variant(
                        name,
                        variant_index,
                        variant,
                        len,
                    )?,
                })
            }

            fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
                Ok(NotTag {
                    delegate: Serializer.serialize_map(len)?,
                })
            }

            fn serialize_struct(
                self,
                name: &'static str,
                len: usize,
            ) -> Result<Self::SerializeStruct> {
                Ok(NotTag {
                    delegate: Serializer.serialize_struct(name, len)?,
                })
            }

            fn serialize_struct_variant(
                self,
                name: &'static str,
                variant_index: u32,
                variant: &'static str,
                len: usize,
            ) -> Result<Self::SerializeStructVariant> {
                Ok(NotTag {
                    delegate: Serializer.serialize_struct_variant(
                        name,
                        variant_index,
                        variant,
                        len,
                    )?,
                })
            }

            fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
            where
                T: ?Sized + Display,
            {
                Ok(match tagged::check_for_tag(value) {
                    MaybeTag::Tag(tag) => MaybeTag::Tag(tag),
                    MaybeTag::NotTag(string) => MaybeTag::NotTag(Value::String(string)),
                })
            }
        }

        impl ser::SerializeSeq for NotTag<SerializeArray> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        impl ser::SerializeTuple for NotTag<SerializeArray> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        impl ser::SerializeTupleStruct for NotTag<SerializeArray> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        impl ser::SerializeTupleVariant for NotTag<SerializeTupleVariant> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        impl ser::SerializeMap for NotTag<SerializeMap> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        impl ser::SerializeStruct for NotTag<SerializeStruct> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        impl ser::SerializeStructVariant for NotTag<SerializeStructVariant> {
            type Ok = MaybeTag<Value>;
            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<Self::Ok> {
                self.delegate.end().map(MaybeTag::NotTag)
            }
        }

        match self {
            SerializeMap::CheckForTag => {
                let key = key.serialize(CheckForTag)?;
                let mut mapping = Mapping::new();
                *self = match key {
                    MaybeTag::Tag(string) => SerializeMap::Tagged(TaggedValue {
                        tag: Tag::new(string),
                        value: to_value(value)?,
                    }),
                    MaybeTag::NotTag(key) => {
                        mapping.insert(key, to_value(value)?);
                        SerializeMap::Untagged {
                            mapping,
                            next_key: None,
                        }
                    }
                };
            }
            SerializeMap::Tagged(tagged) => {
                let mut mapping = Mapping::new();
                mapping.insert(
                    Value::String(tagged.tag.to_string()),
                    mem::take(&mut tagged.value),
                );
                mapping.insert(to_value(key)?, to_value(value)?);
                *self = SerializeMap::Untagged {
                    mapping,
                    next_key: None,
                };
            }
            SerializeMap::Untagged { mapping, .. } => {
                mapping.insert(to_value(key)?, to_value(value)?);
            }
        }
        Ok(())
    }

    fn end(self) -> Result<Value> {
        Ok(match self {
            SerializeMap::CheckForTag => Value::Mapping(Mapping::new()),
            SerializeMap::Tagged(tagged) => Value::Tagged(Box::new(tagged)),
            SerializeMap::Untagged { mapping, .. } => Value::Mapping(mapping),
        })
    }
}

pub struct SerializeStruct {
    mapping: Mapping,
}

impl ser::SerializeStruct for SerializeStruct {
    type Ok = Value;
    type Error = Error;

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

    fn end(self) -> Result<Value> {
        Ok(Value::Mapping(self.mapping))
    }
}

pub struct SerializeStructVariant {
    tag: &'static str,
    mapping: Mapping,
}

impl ser::SerializeStructVariant for SerializeStructVariant {
    type Ok = Value;
    type Error = Error;

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

    fn end(self) -> Result<Value> {
        Ok(Value::Tagged(Box::new(TaggedValue {
            tag: Tag::new(self.tag),
            value: Value::Mapping(self.mapping),
        })))
    }
}