table/value/

serde.rs

// Copyright (C) 2018  Project Tsukurou!
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use std::collections::HashMap;
use std::fmt;

use serde::ser::{self, Error, SerializeSeq};
use serde::de;

use table::Table;
use value::Value;

/// Serializes this object into its `Value` representation.
pub fn to_value<T>(t: &T) -> Result<Value, SerializeError>
where
    T: ser::Serialize,
{
    t.serialize(ValueSerializer)
}

/// Deserializes an object from a `Value`.
pub fn from_value<'de, T>(value: &'de Value) -> Result<T, DeserializeError>
where
    T: de::Deserialize<'de>,
{
    T::deserialize(value)
}

impl ser::Serialize for Value {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ser::Serializer,
    {
        match self {
            Value::Null => serializer.serialize_none(),
            Value::Boolean(x) => serializer.serialize_bool(*x),
            Value::Integer(x) => serializer.serialize_i64(*x),
            Value::Number(x) => serializer.serialize_f64(*x),
            Value::Text(x) => serializer.serialize_str(x),
            Value::List(x) => x.serialize(serializer),
            Value::Table(x) => x.serialize(serializer),
        }
    }
}

impl<'de> de::Deserialize<'de> for Value {
    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        struct ValueVisitor;
        impl<'v> de::Visitor<'v> for ValueVisitor {
            type Value = Value;
            
            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
                write!(f, "a boolean, integer, float, string, array, or map")
            }

            fn visit_bool<E: de::Error>(self, x: bool) -> Result<Value, E> {
                Ok(Value::Boolean(x))
            }

            fn visit_i64<E: de::Error>(self, x: i64) -> Result<Value, E> {
                Ok(Value::Integer(x))
            }
            
            fn visit_u64<E: de::Error>(self, x: u64) -> Result<Value, E> {
                if x <= i64::max_value() as u64 {
                    self.visit_i64(x as i64)
                } else {
                    Err(E::invalid_value(
                        de::Unexpected::Unsigned(x),
                        &"an integer within the range -2**63..2**63",
                    ))
                }
            }

            fn visit_f64<E: de::Error>(self, x: f64) -> Result<Value, E> {
                Ok(Value::Number(x))
            }
            
            fn visit_str<E: de::Error>(self, x: &str) -> Result<Value, E> {
                Ok(Value::Text(x.to_string()))
            }

            fn visit_none<E: de::Error>(self) -> Result<Value, E> {
                Ok(Value::Null)
            }

            fn visit_some<D: de::Deserializer<'v>>(self, deserializer: D)
                -> Result<Value, D::Error>
            {
                deserializer.deserialize_any(self)
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Value, A::Error>
            where
                A: de::SeqAccess<'v>,
            {
                let mut vec = Vec::new();
                if let Some(size) = seq.size_hint() {
                    vec.reserve(size);
                }
                while let Some(v) = seq.next_element()? {
                    vec.push(v);
                }
                Ok(Value::List(vec))
            }

            fn visit_map<A>(self, mut map: A) -> Result<Value, A::Error>
            where
                A: de::MapAccess<'v>,
            {
                let mut hash_map = HashMap::new();
                if let Some(size) = map.size_hint() {
                    hash_map.reserve(size);
                }
                while let Some((k, v)) = map.next_entry()? {
                    hash_map.insert(k, v);
                }
                Ok(Value::Table(Table::from(hash_map)))
            }
        }

        deserializer.deserialize_any(ValueVisitor)
    }
}

#[derive(Debug)]
pub struct SerializeError {
    description: String,
}

impl ::std::error::Error for SerializeError {}

impl ser::Error for SerializeError {
    fn custom<T>(msg: T) -> Self
    where
        T: fmt::Display,
    {
        SerializeError {
            description: msg.to_string(),
        }
    }
}

impl fmt::Display for SerializeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.description)
    }
}

pub struct ValueSerializer;

pub struct ListSerializer {
    buf: Vec<Value>,
}

pub struct TableSerializer {
    buf: HashMap<String, Value>,
    key: Option<String>,
}

pub struct ListVariantSerializer {
    variant: &'static str,
    buf: Vec<Value>,
}

pub struct TableVariantSerializer {
    variant: &'static str,
    buf: HashMap<String, Value>,
}

impl ser::Serializer for ValueSerializer {
    type Ok = Value;
    type Error = SerializeError;
    type SerializeSeq = ListSerializer;
    type SerializeTuple = ListSerializer;
    type SerializeTupleStruct = ListSerializer;
    type SerializeMap = TableSerializer;
    type SerializeStruct = TableSerializer;
    type SerializeTupleVariant = ListVariantSerializer;
    type SerializeStructVariant = TableVariantSerializer;

    fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Boolean(value))
    }

    fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(value as i64)
    }

    fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(value as i64)
    }

    fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(value as i64)
    }

    fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Integer(value))
    }

    fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(value as u64)
    }

    fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(value as u64)
    }

    fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(value as u64)
    }

    fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
        if value <= i64::max_value() as u64 {
            self.serialize_i64(value as i64)
        } else {
            Err(SerializeError::custom("Integer out of bounds"))
        }
    }

    fn serialize_f32(self, value: f32) -> Result<Self::Ok, Self::Error> {
        self.serialize_f64(value as f64)
    }

    fn serialize_f64(self, value: f64) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Number(value))
    }

    fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Text(value.to_string()))
    }
    
    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Text(value.to_string()))
    }

    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
        let mut seq = self.serialize_seq(Some(value.len()))?;
        for x in value {
            seq.serialize_element(x)?;
        }
        seq.end()
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.serialize_unit()
    }

    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        value.serialize(self)
    }

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

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

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        _index: u32,
        variant: &'static str
    ) 
        -> Result<Self::Ok, Self::Error>
    {
        self.serialize_str(variant)
    }

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

    fn serialize_newtype_variant<T>(
        self,
        _name: &'static str,
        _index: u32,
        variant: &'static str,
        value: &T,
    )
        -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        let mut table = Table::new();
        table.set(variant, value.serialize(self)?);
        Ok(Value::Table(table))
    }

    fn serialize_seq(self, len: Option<usize>)
        -> Result<Self::SerializeSeq, Self::Error>
    {
        let buf = match len {
            Some(x) => Vec::with_capacity(x),
            None => Vec::new(),
        };

        Ok(ListSerializer {
            buf,
        })
    }

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

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

    fn serialize_map(self, len: Option<usize>)
        -> Result<Self::SerializeMap, Self::Error>
    {
        let buf = match len {
            Some(x) => HashMap::with_capacity(x),
            None => HashMap::new(),
        };

        Ok(TableSerializer {
            buf,
            key: None,
        })
    }

    fn serialize_struct(self, _name: &'static str, len: usize)
        -> Result<Self::SerializeStruct, Self::Error>
    {
        self.serialize_map(Some(len))
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _index: u32,
        variant: &'static str,
        len: usize
    )
        -> Result<Self::SerializeTupleVariant, Self::Error>
    {
        Ok(ListVariantSerializer {
            variant,
            buf: Vec::with_capacity(len),
        })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _index: u32,
        variant: &'static str,
        len: usize,
    )
        -> Result<Self::SerializeStructVariant, Self::Error>
    {
        Ok(TableVariantSerializer {
            variant,
            buf: HashMap::with_capacity(len),
        })
    }
}

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

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        self.buf.push(value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Value::List(self.buf))
    }
}

impl ser::SerializeTuple for ListSerializer {
    type Ok = Value;
    type Error = SerializeError;

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        self.buf.push(value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Value::List(self.buf))
    }
}

impl ser::SerializeTupleStruct for ListSerializer {
    type Ok = Value;
    type Error = SerializeError;

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        self.buf.push(value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Value::List(self.buf))
    }
}

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

    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        if let Value::Text(key) = key.serialize(ValueSerializer)? {
            self.key = Some(key);
            Ok(())
        } else {
            Err(SerializeError::custom("Table keys must be a string type."))
        }
    }

    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        let key = self.key.take().unwrap();
        self.buf.insert(key, value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn serialize_entry<K, V>(&mut self, key: &K, value: &V)
        -> Result<(), Self::Error>
    where
        K: ser::Serialize + ?Sized,
        V: ser::Serialize + ?Sized,
    {
        if let Value::Text(key) = key.serialize(ValueSerializer)? {
            self.buf.insert(key, value.serialize(ValueSerializer)?);
            Ok(())
        } else {
            Err(SerializeError::custom("Table keys must be a string type."))
        }
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Table(Table::from(self.buf)))
    }
}

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

    fn serialize_field<T>(&mut self, key: &'static str, value: &T)
        -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        self.buf.insert(key.to_string(), value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Value::Table(Table::from(self.buf)))
    }
}

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

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        self.buf.push(value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let mut table = Table::new();
        table.set(self.variant, self.buf);
        Ok(Value::Table(table))
    }
}

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

    fn serialize_field<T>(&mut self, key: &'static str, value: &T)
        -> Result<(), Self::Error>
    where
        T: ser::Serialize + ?Sized,
    {
        self.buf.insert(key.to_string(), value.serialize(ValueSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let mut table = Table::new();
        table.set(self.variant, Table::from(self.buf));
        Ok(Value::Table(table))
    }
}

#[derive(Debug)]
pub struct DeserializeError {
    description: String,
}

impl ::std::error::Error for DeserializeError {}

impl de::Error for DeserializeError {
    fn custom<T>(msg: T) -> Self
    where
        T: fmt::Display,
    {
        DeserializeError {
            description: msg.to_string(),
        }
    }
}

impl fmt::Display for DeserializeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.description)
    }
}

impl<'de> de::Deserializer<'de> for &'de Value {
    type Error = DeserializeError;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        match self {
            Value::Null => visitor.visit_none(),
            Value::Boolean(x) => visitor.visit_bool(*x),
            Value::Integer(x) => visitor.visit_i64(*x),
            Value::Number(x) => visitor.visit_f64(*x),
            Value::Text(ref x) => visitor.visit_borrowed_str(x),
            Value::List(ref x) => {
                let seq = de::value::SeqDeserializer::new(x.iter());
                visitor.visit_seq(seq)
            },
            Value::Table(ref x) => {
                let map = de::value::MapDeserializer::new(
                    x.iter().map(|(k, v)| (k.as_str(), v))
                );
                visitor.visit_map(map)
            },
        }
    }

    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
        map struct enum identifier ignored_any
    }
}

impl<'de> de::IntoDeserializer<'de, DeserializeError> for &'de Value {
    type Deserializer = &'de Value;

     fn into_deserializer(self) -> Self::Deserializer {
         self
     }
}