use std::fmt;
use std::i64;
use std::io;
use std::ops;
use std::slice;
use std::str;
use std::vec;
use std::borrow::Cow;
use serde::de::{self, Unexpected};
use serde::ser;
use serde::de::value::ValueDeserializer;
use error::{Error, ErrorCode};
pub use map::Map;
pub use number::Number;
#[derive(Debug, Clone, PartialEq)]
pub enum Value {
Null,
Bool(bool),
Number(Number),
String(String),
Array(Vec<Value>),
Object(Map<String, Value>),
}
fn parse_index(s: &str) -> Option<usize> {
if s.starts_with('+') || (s.starts_with('0') && s.len() != 1) {
return None;
}
s.parse().ok()
}
impl Value {
pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
index.index_into(self)
}
pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
index.index_into_mut(self)
}
pub fn is_object(&self) -> bool {
self.as_object().is_some()
}
pub fn as_object(&self) -> Option<&Map<String, Value>> {
match *self {
Value::Object(ref map) => Some(map),
_ => None,
}
}
pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>> {
match *self {
Value::Object(ref mut map) => Some(map),
_ => None,
}
}
pub fn is_array(&self) -> bool {
self.as_array().is_some()
}
pub fn as_array(&self) -> Option<&Vec<Value>> {
match *self {
Value::Array(ref array) => Some(&*array),
_ => None,
}
}
pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
match *self {
Value::Array(ref mut list) => Some(list),
_ => None,
}
}
pub fn is_string(&self) -> bool {
self.as_str().is_some()
}
pub fn as_str(&self) -> Option<&str> {
match *self {
Value::String(ref s) => Some(s),
_ => None,
}
}
pub fn is_number(&self) -> bool {
match *self {
Value::Number(_) => true,
_ => false,
}
}
pub fn is_i64(&self) -> bool {
match *self {
Value::Number(ref n) => n.is_i64(),
_ => false,
}
}
pub fn is_u64(&self) -> bool {
match *self {
Value::Number(ref n) => n.is_u64(),
_ => false,
}
}
pub fn is_f64(&self) -> bool {
match *self {
Value::Number(ref n) => n.is_f64(),
_ => false,
}
}
pub fn as_i64(&self) -> Option<i64> {
match *self {
Value::Number(ref n) => n.as_i64(),
_ => None,
}
}
pub fn as_u64(&self) -> Option<u64> {
match *self {
Value::Number(ref n) => n.as_u64(),
_ => None,
}
}
pub fn as_f64(&self) -> Option<f64> {
match *self {
Value::Number(ref n) => n.as_f64(),
_ => None,
}
}
pub fn is_boolean(&self) -> bool {
self.as_bool().is_some()
}
pub fn as_bool(&self) -> Option<bool> {
match *self {
Value::Bool(b) => Some(b),
_ => None,
}
}
pub fn is_null(&self) -> bool {
self.as_null().is_some()
}
pub fn as_null(&self) -> Option<()> {
match *self {
Value::Null => Some(()),
_ => None,
}
}
pub fn pointer<'a>(&'a self, pointer: &str) -> Option<&'a Value> {
if pointer == "" {
return Some(self);
}
if !pointer.starts_with('/') {
return None;
}
let tokens = pointer.split('/').skip(1).map(|x| x.replace("~1", "/").replace("~0", "~"));
let mut target = self;
for token in tokens {
let target_opt = match *target {
Value::Object(ref map) => map.get(&token),
Value::Array(ref list) => parse_index(&token).and_then(|x| list.get(x)),
_ => return None,
};
if let Some(t) = target_opt {
target = t;
} else {
return None;
}
}
Some(target)
}
pub fn pointer_mut<'a>(&'a mut self, pointer: &str) -> Option<&'a mut Value> {
if pointer == "" {
return Some(self);
}
if !pointer.starts_with('/') {
return None;
}
let tokens = pointer.split('/').skip(1).map(|x| x.replace("~1", "/").replace("~0", "~"));
let mut target = self;
for token in tokens {
let target_once = target;
let target_opt = match *target_once {
Value::Object(ref mut map) => map.get_mut(&token),
Value::Array(ref mut list) => parse_index(&token).and_then(move |x| list.get_mut(x)),
_ => return None,
};
if let Some(t) = target_opt {
target = t;
} else {
return None;
}
}
Some(target)
}
}
impl Default for Value {
fn default() -> Value {
Value::Null
}
}
pub trait Index: private::Sealed {
#[doc(hidden)]
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;
#[doc(hidden)]
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
#[doc(hidden)]
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
}
impl Index for usize {
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
match *v {
Value::Array(ref vec) => vec.get(*self),
_ => None,
}
}
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
match *v {
Value::Array(ref mut vec) => vec.get_mut(*self),
_ => None,
}
}
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
match *v {
Value::Array(ref mut vec) => {
let len = vec.len();
vec.get_mut(*self).unwrap_or_else(|| {
panic!("cannot access index {} of JSON array of length {}",
self, len)
})
}
_ => panic!("cannot access index {} of JSON {}", self, Type(v)),
}
}
}
impl Index for str {
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
match *v {
Value::Object(ref map) => map.get(self),
_ => None,
}
}
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
match *v {
Value::Object(ref mut map) => map.get_mut(self),
_ => None,
}
}
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
if let Value::Null = *v {
let mut map = Map::new();
map.insert(self.to_owned(), Value::Null);
*v = Value::Object(map);
}
match *v {
Value::Object(ref mut map) => {
if !map.contains_key(self) {
map.insert(self.to_owned(), Value::Null);
}
map.get_mut(self).unwrap()
}
_ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
}
}
}
impl Index for String {
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
self[..].index_into(v)
}
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
self[..].index_into_mut(v)
}
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
self[..].index_or_insert(v)
}
}
impl<'a, T: ?Sized> Index for &'a T where T: Index {
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
(**self).index_into(v)
}
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
(**self).index_into_mut(v)
}
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
(**self).index_or_insert(v)
}
}
mod private {
pub trait Sealed {}
impl Sealed for usize {}
impl Sealed for str {}
impl Sealed for String {}
impl<'a, T: ?Sized> Sealed for &'a T where T: Sealed {}
}
struct Type<'a>(&'a Value);
impl<'a> fmt::Display for Type<'a> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
match *self.0 {
Value::Null => formatter.write_str("null"),
Value::Bool(_) => formatter.write_str("boolean"),
Value::Number(_) => formatter.write_str("number"),
Value::String(_) => formatter.write_str("string"),
Value::Array(_) => formatter.write_str("array"),
Value::Object(_) => formatter.write_str("object"),
}
}
}
impl<I> ops::Index<I> for Value where I: Index {
type Output = Value;
fn index(&self, index: I) -> &Value {
static NULL: Value = Value::Null;
index.index_into(self).unwrap_or(&NULL)
}
}
impl<I> ops::IndexMut<I> for Value where I: Index {
fn index_mut(&mut self, index: I) -> &mut Value {
index.index_or_insert(self)
}
}
impl PartialEq<str> for Value {
fn eq(&self, other: &str) -> bool {
self.as_str().map_or(false, |s| s == other)
}
}
impl<'a> PartialEq<&'a str> for Value {
fn eq(&self, other: &&str) -> bool {
self.as_str().map_or(false, |s| s == *other)
}
}
impl PartialEq<Value> for str {
fn eq(&self, other: &Value) -> bool {
other.as_str().map_or(false, |s| s == self)
}
}
impl<'a> PartialEq<Value> for &'a str {
fn eq(&self, other: &Value) -> bool {
other.as_str().map_or(false, |s| s == *self)
}
}
impl PartialEq<String> for Value {
fn eq(&self, other: &String) -> bool {
self.as_str().map_or(false, |s| s == other)
}
}
impl PartialEq<Value> for String {
fn eq(&self, other: &Value) -> bool {
other.as_str().map_or(false, |s| s == self)
}
}
macro_rules! partialeq_numeric {
($([$($ty:ty)*], $conversion:ident, $base:ty)*) => {
$($(
impl PartialEq<$ty> for Value {
fn eq(&self, other: &$ty) -> bool {
self.$conversion().map_or(false, |i| i == (*other as $base))
}
}
impl PartialEq<Value> for $ty {
fn eq(&self, other: &Value) -> bool {
other.$conversion().map_or(false, |i| i == (*self as $base))
}
}
impl<'a> PartialEq<$ty> for &'a Value {
fn eq(&self, other: &$ty) -> bool {
self.$conversion().map_or(false, |i| i == (*other as $base))
}
}
impl<'a> PartialEq<$ty> for &'a mut Value {
fn eq(&self, other: &$ty) -> bool {
self.$conversion().map_or(false, |i| i == (*other as $base))
}
}
)*)*
}
}
partialeq_numeric! {
[i8 i16 i32 i64 isize], as_i64, i64
[u8 u16 u32 u64 usize], as_u64, u64
[f32 f64], as_f64, f64
}
macro_rules! from_integer {
($($ty:ident)*) => {
$(
impl From<$ty> for Value {
fn from(n: $ty) -> Self {
Value::Number(n.into())
}
}
)*
};
}
from_integer! {
i8 i16 i32 i64 isize
u8 u16 u32 u64 usize
}
impl From<f32> for Value {
fn from(f: f32) -> Self {
From::from(f as f64)
}
}
impl From<f64> for Value {
fn from(f: f64) -> Self {
Number::from_f64(f).map_or(Value::Null, Value::Number)
}
}
impl From<bool> for Value {
fn from(f: bool) -> Self {
Value::Bool(f)
}
}
impl From<String> for Value {
fn from(f: String) -> Self {
Value::String(f)
}
}
impl<'a> From<&'a str> for Value {
fn from(f: &str) -> Self {
Value::String(f.to_string())
}
}
impl<'a> From<Cow<'a, str>> for Value {
fn from(f: Cow<'a, str>) -> Self {
Value::String(f.to_string())
}
}
impl From<Map<String, Value>> for Value {
fn from(f: Map<String, Value>) -> Self {
Value::Object(f)
}
}
impl<T: Into<Value>> From<Vec<T>> for Value {
fn from(f: Vec<T>) -> Self {
Value::Array(f.into_iter().map(Into::into).collect())
}
}
impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value {
fn from(f: &'a [T]) -> Self {
Value::Array(f.into_iter().cloned().map(Into::into).collect())
}
}
impl<T: Into<Value>> ::std::iter::FromIterator<T> for Value {
fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> Self {
let vec: Vec<Value> = iter.into_iter().map(|x| x.into()).collect();
Value::Array(vec)
}
}
impl ser::Serialize for Value {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
match *self {
Value::Null => serializer.serialize_unit(),
Value::Bool(b) => serializer.serialize_bool(b),
Value::Number(ref n) => n.serialize(serializer),
Value::String(ref s) => serializer.serialize_str(s),
Value::Array(ref v) => v.serialize(serializer),
Value::Object(ref m) => {
use serde::ser::SerializeMap;
let mut map = try!(serializer.serialize_map(Some(m.len())));
for (k, v) in m {
try!(map.serialize_key(k));
try!(map.serialize_value(v));
}
map.end()
}
}
}
}
impl de::Deserialize for Value {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
where D: de::Deserializer,
{
struct ValueVisitor;
impl de::Visitor for ValueVisitor {
type Value = Value;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("any valid JSON value")
}
#[inline]
fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
Ok(Value::Bool(value))
}
#[inline]
fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
Ok(Value::Number(value.into()))
}
#[inline]
fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
Ok(Value::Number(value.into()))
}
#[inline]
fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
}
#[inline]
fn visit_str<E>(self, value: &str) -> Result<Value, E>
where E: de::Error,
{
self.visit_string(String::from(value))
}
#[inline]
fn visit_string<E>(self, value: String) -> Result<Value, E> {
Ok(Value::String(value))
}
#[inline]
fn visit_none<E>(self) -> Result<Value, E> {
Ok(Value::Null)
}
#[inline]
fn visit_some<D>(
self,
deserializer: D
) -> Result<Value, D::Error>
where D: de::Deserializer,
{
de::Deserialize::deserialize(deserializer)
}
#[inline]
fn visit_unit<E>(self) -> Result<Value, E> {
Ok(Value::Null)
}
#[inline]
fn visit_seq<V>(self, visitor: V) -> Result<Value, V::Error>
where V: de::SeqVisitor,
{
let values = try!(de::impls::VecVisitor::new()
.visit_seq(visitor));
Ok(Value::Array(values))
}
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
where V: de::MapVisitor,
{
let mut values = Map::with_capacity(visitor.size_hint().0);
while let Some((key, value)) = try!(visitor.visit()) {
values.insert(key, value);
}
Ok(Value::Object(values))
}
}
deserializer.deserialize(ValueVisitor)
}
}
struct WriterFormatter<'a, 'b: 'a> {
inner: &'a mut fmt::Formatter<'b>,
}
impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
fn io_error<E>(_: E) -> io::Error {
io::Error::new(io::ErrorKind::Other, "fmt error")
}
let s = try!(str::from_utf8(buf).map_err(io_error));
try!(self.inner.write_str(s).map_err(io_error));
Ok(buf.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl fmt::Display for Value {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let alternate = f.alternate();
let mut wr = WriterFormatter {
inner: f,
};
if alternate {
super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
} else {
super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
}
}
}
impl str::FromStr for Value {
type Err = Error;
fn from_str(s: &str) -> Result<Value, Error> {
super::de::from_str(s)
}
}
struct Serializer;
impl ser::Serializer for Serializer {
type Ok = Value;
type Error = Error;
type SerializeSeq = SerializeVec;
type SerializeTuple = SerializeVec;
type SerializeTupleStruct = SerializeVec;
type SerializeTupleVariant = SerializeTupleVariant;
type SerializeMap = SerializeMap;
type SerializeStruct = SerializeMap;
type SerializeStructVariant = SerializeStructVariant;
#[inline]
fn serialize_bool(self, value: bool) -> Result<Value, Error> {
Ok(Value::Bool(value))
}
#[inline]
fn serialize_i8(self, value: i8) -> Result<Value, Error> {
self.serialize_i64(value as i64)
}
#[inline]
fn serialize_i16(self, value: i16) -> Result<Value, Error> {
self.serialize_i64(value as i64)
}
#[inline]
fn serialize_i32(self, value: i32) -> Result<Value, Error> {
self.serialize_i64(value as i64)
}
fn serialize_i64(self, value: i64) -> Result<Value, Error> {
Ok(Value::Number(value.into()))
}
#[inline]
fn serialize_u8(self, value: u8) -> Result<Value, Error> {
self.serialize_u64(value as u64)
}
#[inline]
fn serialize_u16(self, value: u16) -> Result<Value, Error> {
self.serialize_u64(value as u64)
}
#[inline]
fn serialize_u32(self, value: u32) -> Result<Value, Error> {
self.serialize_u64(value as u64)
}
#[inline]
fn serialize_u64(self, value: u64) -> Result<Value, Error> {
Ok(Value::Number(value.into()))
}
#[inline]
fn serialize_f32(self, value: f32) -> Result<Value, Error> {
self.serialize_f64(value as f64)
}
#[inline]
fn serialize_f64(self, value: f64) -> Result<Value, Error> {
Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
}
#[inline]
fn serialize_char(self, value: char) -> Result<Value, Error> {
let mut s = String::new();
s.push(value);
self.serialize_str(&s)
}
#[inline]
fn serialize_str(self, value: &str) -> Result<Value, Error> {
Ok(Value::String(value.to_owned()))
}
fn serialize_bytes(self, value: &[u8]) -> Result<Value, Error> {
let vec = value.iter().map(|&b| Value::Number(b.into())).collect();
Ok(Value::Array(vec))
}
#[inline]
fn serialize_unit(self) -> Result<Value, Error> {
Ok(Value::Null)
}
#[inline]
fn serialize_unit_struct(
self,
_name: &'static str
) -> Result<Value, Error> {
self.serialize_unit()
}
#[inline]
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str
) -> Result<Value, Error> {
self.serialize_str(variant)
}
#[inline]
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result<Value, Error>
where T: ser::Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str,
value: &T
) -> Result<Value, Error>
where T: ser::Serialize,
{
let mut values = Map::new();
values.insert(String::from(variant), try!(to_value(&value)));
Ok(Value::Object(values))
}
#[inline]
fn serialize_none(self) -> Result<Value, Error> {
self.serialize_unit()
}
#[inline]
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, Error>
where T: ser::Serialize,
{
value.serialize(self)
}
fn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Error> {
Ok(SerializeVec {
vec: Vec::with_capacity(len.unwrap_or(0))
})
}
fn serialize_seq_fixed_size(
self,
size: usize
) -> Result<Self::SerializeSeq, Error> {
self.serialize_seq(Some(size))
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> {
self.serialize_seq(Some(len))
}
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Error> {
self.serialize_seq(Some(len))
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Error> {
Ok(SerializeTupleVariant {
name: String::from(variant),
vec: Vec::with_capacity(len),
})
}
fn serialize_map(
self,
_len: Option<usize>
) -> Result<Self::SerializeMap, Error> {
Ok(SerializeMap {
map: Map::new(),
next_key: None,
})
}
fn serialize_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeStruct, Error> {
self.serialize_map(Some(len))
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant, Error> {
Ok(SerializeStructVariant {
name: String::from(variant),
map: Map::new(),
})
}
}
#[doc(hidden)]
pub struct SerializeVec {
vec: Vec<Value>,
}
#[doc(hidden)]
pub struct SerializeTupleVariant {
name: String,
vec: Vec<Value>,
}
#[doc(hidden)]
pub struct SerializeMap {
map: Map<String, Value>,
next_key: Option<String>,
}
#[doc(hidden)]
pub struct SerializeStructVariant {
name: String,
map: Map<String, Value>,
}
impl ser::SerializeSeq for SerializeVec {
type Ok = Value;
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
self.vec.push(try!(to_value(&value)));
Ok(())
}
fn end(self) -> Result<Value, Error> {
Ok(Value::Array(self.vec))
}
}
impl ser::SerializeTuple for SerializeVec {
type Ok = Value;
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
ser::SerializeSeq::serialize_element(self, value)
}
fn end(self) -> Result<Value, Error> {
ser::SerializeSeq::end(self)
}
}
impl ser::SerializeTupleStruct for SerializeVec {
type Ok = Value;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
ser::SerializeSeq::serialize_element(self, value)
}
fn end(self) -> Result<Value, Error> {
ser::SerializeSeq::end(self)
}
}
impl ser::SerializeTupleVariant for SerializeTupleVariant {
type Ok = Value;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
self.vec.push(try!(to_value(&value)));
Ok(())
}
fn end(self) -> Result<Value, Error> {
let mut object = Map::new();
object.insert(self.name, Value::Array(self.vec));
Ok(Value::Object(object))
}
}
impl ser::SerializeMap for SerializeMap {
type Ok = Value;
type Error = Error;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
where T: ser::Serialize
{
match try!(to_value(&key)) {
Value::String(s) => self.next_key = Some(s),
Value::Number(n) => {
if n.is_u64() || n.is_i64() {
self.next_key = Some(n.to_string())
} else {
return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0))
}
}
_ => return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)),
};
Ok(())
}
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
let key = self.next_key.take();
let key = key.expect("serialize_value called before serialize_key");
self.map.insert(key, try!(to_value(&value)));
Ok(())
}
fn end(self) -> Result<Value, Error> {
Ok(Value::Object(self.map))
}
}
impl ser::SerializeStruct for SerializeMap {
type Ok = Value;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
try!(ser::SerializeMap::serialize_key(self, key));
ser::SerializeMap::serialize_value(self, value)
}
fn end(self) -> Result<Value, Error> {
ser::SerializeMap::end(self)
}
}
impl ser::SerializeStructVariant for SerializeStructVariant {
type Ok = Value;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where T: ser::Serialize
{
self.map.insert(String::from(key), try!(to_value(&value)));
Ok(())
}
fn end(self) -> Result<Value, Error> {
let mut object = Map::new();
object.insert(self.name, Value::Object(self.map));
Ok(Value::Object(object))
}
}
impl de::Deserializer for Value {
type Error = Error;
#[inline]
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self {
Value::Null => visitor.visit_unit(),
Value::Bool(v) => visitor.visit_bool(v),
Value::Number(n) => n.deserialize(visitor),
Value::String(v) => visitor.visit_string(v),
Value::Array(v) => {
let len = v.len();
let mut deserializer = SeqDeserializer::new(v);
let seq = try!(visitor.visit_seq(&mut deserializer));
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(seq)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in array"))
}
}
Value::Object(v) => {
let len = v.len();
let mut deserializer = MapDeserializer::new(v);
let map = try!(visitor.visit_map(&mut deserializer));
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(map)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in map"))
}
}
}
}
#[inline]
fn deserialize_option<V>(
self,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self {
Value::Null => visitor.visit_none(),
_ => visitor.visit_some(self),
}
}
#[inline]
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
let (variant, value) = match self {
Value::Object(value) => {
let mut iter = value.into_iter();
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
}
};
if iter.next().is_some() {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
}
(variant, Some(value))
}
Value::String(variant) => (variant, None),
other => {
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
}
};
visitor.visit_enum(EnumDeserializer {
variant: variant,
value: value,
})
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_newtype_struct(self)
}
forward_to_deserialize! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
seq_fixed_size bytes byte_buf map unit_struct tuple_struct struct
struct_field tuple ignored_any
}
}
struct EnumDeserializer {
variant: String,
value: Option<Value>,
}
impl de::EnumVisitor for EnumDeserializer {
type Error = Error;
type Variant = VariantDeserializer;
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
where V: de::DeserializeSeed,
{
let variant = self.variant.into_deserializer();
let visitor = VariantDeserializer { value: self.value };
seed.deserialize(variant).map(|v| (v, visitor))
}
}
struct VariantDeserializer {
value: Option<Value>,
}
impl de::VariantVisitor for VariantDeserializer {
type Error = Error;
fn visit_unit(self) -> Result<(), Error> {
match self.value {
Some(value) => de::Deserialize::deserialize(value),
None => Ok(()),
}
}
fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed,
{
match self.value {
Some(value) => seed.deserialize(value),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")),
}
}
fn visit_tuple<V>(
self,
_len: usize,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.value {
Some(Value::Array(v)) => {
de::Deserializer::deserialize(SeqDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
}
}
fn visit_struct<V>(
self,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.value {
Some(Value::Object(v)) => {
de::Deserializer::deserialize(MapDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
_ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
}
}
}
struct SeqDeserializer {
iter: vec::IntoIter<Value>,
}
impl SeqDeserializer {
fn new(vec: Vec<Value>) -> Self {
SeqDeserializer {
iter: vec.into_iter(),
}
}
}
impl de::Deserializer for SeqDeserializer {
type Error = Error;
#[inline]
fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
let len = self.iter.len();
if len == 0 {
visitor.visit_unit()
} else {
let ret = try!(visitor.visit_seq(&mut self));
let remaining = self.iter.len();
if remaining == 0 {
Ok(ret)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in array"))
}
}
}
forward_to_deserialize! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
tuple_struct struct struct_field tuple enum ignored_any
}
}
impl de::SeqVisitor for SeqDeserializer {
type Error = Error;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed,
{
match self.iter.next() {
Some(value) => seed.deserialize(value).map(Some),
None => Ok(None),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
struct MapDeserializer {
iter: <Map<String, Value> as IntoIterator>::IntoIter,
value: Option<Value>,
}
impl MapDeserializer {
fn new(map: Map<String, Value>) -> Self {
MapDeserializer {
iter: map.into_iter(),
value: None,
}
}
}
impl de::MapVisitor for MapDeserializer {
type Error = Error;
fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed,
{
match self.iter.next() {
Some((key, value)) => {
self.value = Some(value);
seed.deserialize(key.into_deserializer()).map(Some)
}
None => Ok(None),
}
}
fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed,
{
match self.value.take() {
Some(value) => seed.deserialize(value),
None => Err(de::Error::custom("value is missing")),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl de::Deserializer for MapDeserializer {
type Error = Error;
#[inline]
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
visitor.visit_map(self)
}
forward_to_deserialize! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
tuple_struct struct struct_field tuple enum ignored_any
}
}
impl<'a> de::Deserializer for &'a Value {
type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match *self {
Value::Null => visitor.visit_unit(),
Value::Bool(v) => visitor.visit_bool(v),
Value::Number(ref n) => n.deserialize(visitor),
Value::String(ref v) => visitor.visit_str(v),
Value::Array(ref v) => {
let len = v.len();
let mut deserializer = SeqRefDeserializer::new(v);
let seq = try!(visitor.visit_seq(&mut deserializer));
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(seq)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in array"))
}
}
Value::Object(ref v) => {
let len = v.len();
let mut deserializer = MapRefDeserializer::new(v);
let map = try!(visitor.visit_map(&mut deserializer));
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(map)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in map"))
}
}
}
}
fn deserialize_option<V>(
self,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
match *self {
Value::Null => visitor.visit_none(),
_ => visitor.visit_some(self),
}
}
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
let (variant, value) = match *self {
Value::Object(ref value) => {
let mut iter = value.into_iter();
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
}
};
if iter.next().is_some() {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
}
(variant, Some(value))
}
Value::String(ref variant) => (variant, None),
ref other => {
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
}
};
visitor.visit_enum(EnumRefDeserializer {
variant: variant,
value: value,
})
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_newtype_struct(self)
}
forward_to_deserialize! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
seq_fixed_size bytes byte_buf map unit_struct tuple_struct struct
struct_field tuple ignored_any
}
}
struct EnumRefDeserializer<'a> {
variant: &'a str,
value: Option<&'a Value>,
}
impl<'a> de::EnumVisitor for EnumRefDeserializer<'a> {
type Error = Error;
type Variant = VariantRefDeserializer<'a>;
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
where V: de::DeserializeSeed,
{
let variant = self.variant.into_deserializer();
let visitor = VariantRefDeserializer { value: self.value };
seed.deserialize(variant).map(|v| (v, visitor))
}
}
struct VariantRefDeserializer<'a> {
value: Option<&'a Value>,
}
impl<'a> de::VariantVisitor for VariantRefDeserializer<'a> {
type Error = Error;
fn visit_unit(self) -> Result<(), Error> {
match self.value {
Some(value) => de::Deserialize::deserialize(value),
None => Ok(()),
}
}
fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed,
{
match self.value {
Some(value) => seed.deserialize(value),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")),
}
}
fn visit_tuple<V>(
self,
_len: usize,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.value {
Some(&Value::Array(ref v)) => {
de::Deserializer::deserialize(SeqRefDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
}
}
fn visit_struct<V>(
self,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.value {
Some(&Value::Object(ref v)) => {
de::Deserializer::deserialize(MapRefDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
_ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
}
}
}
struct SeqRefDeserializer<'a> {
iter: slice::Iter<'a, Value>,
}
impl<'a> SeqRefDeserializer<'a> {
fn new(slice: &'a [Value]) -> Self {
SeqRefDeserializer {
iter: slice.iter(),
}
}
}
impl<'a> de::Deserializer for SeqRefDeserializer<'a> {
type Error = Error;
#[inline]
fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
let len = self.iter.len();
if len == 0 {
visitor.visit_unit()
} else {
let ret = try!(visitor.visit_seq(&mut self));
let remaining = self.iter.len();
if remaining == 0 {
Ok(ret)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in array"))
}
}
}
forward_to_deserialize! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
tuple_struct struct struct_field tuple enum ignored_any
}
}
impl<'a> de::SeqVisitor for SeqRefDeserializer<'a> {
type Error = Error;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed,
{
match self.iter.next() {
Some(value) => seed.deserialize(value).map(Some),
None => Ok(None),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
struct MapRefDeserializer<'a> {
iter: <&'a Map<String, Value> as IntoIterator>::IntoIter,
value: Option<&'a Value>,
}
impl<'a> MapRefDeserializer<'a> {
fn new(map: &'a Map<String, Value>) -> Self {
MapRefDeserializer {
iter: map.into_iter(),
value: None,
}
}
}
impl<'a> de::MapVisitor for MapRefDeserializer<'a> {
type Error = Error;
fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed,
{
match self.iter.next() {
Some((key, value)) => {
self.value = Some(value);
seed.deserialize((&**key).into_deserializer()).map(Some)
}
None => Ok(None),
}
}
fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed,
{
match self.value.take() {
Some(value) => seed.deserialize(value),
None => Err(de::Error::custom("value is missing")),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a> de::Deserializer for MapRefDeserializer<'a> {
type Error = Error;
#[inline]
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
visitor.visit_map(self)
}
forward_to_deserialize! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
tuple_struct struct struct_field tuple enum ignored_any
}
}
impl Value {
fn unexpected(&self) -> Unexpected {
match *self {
Value::Null => Unexpected::Unit,
Value::Bool(b) => Unexpected::Bool(b),
Value::Number(ref n) => {
if let Some(u) = n.as_u64() {
Unexpected::Unsigned(u)
} else if let Some(i) = n.as_i64() {
Unexpected::Signed(i)
} else if let Some(f) = n.as_f64() {
Unexpected::Float(f)
} else {
panic!("unexpected number")
}
}
Value::String(ref s) => Unexpected::Str(s),
Value::Array(_) => Unexpected::Seq,
Value::Object(_) => Unexpected::Map,
}
}
}
#[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
pub fn to_value<T>(value: T) -> Result<Value, Error>
where T: ser::Serialize,
{
value.serialize(Serializer)
}
pub fn from_value<T>(value: Value) -> Result<T, Error>
where T: de::Deserialize,
{
de::Deserialize::deserialize(value)
}
pub trait ToJson {
fn to_json(&self) -> Result<Value, Error>;
}
impl<T: ?Sized> ToJson for T
where T: ser::Serialize,
{
fn to_json(&self) -> Result<Value, Error> {
to_value(self)
}
}