diff options
Diffstat (limited to 'vendor/serde_json/src/value')
| -rw-r--r-- | vendor/serde_json/src/value/de.rs | 1419 | ||||
| -rw-r--r-- | vendor/serde_json/src/value/from.rs | 278 | ||||
| -rw-r--r-- | vendor/serde_json/src/value/index.rs | 258 | ||||
| -rw-r--r-- | vendor/serde_json/src/value/mod.rs | 1009 | ||||
| -rw-r--r-- | vendor/serde_json/src/value/partial_eq.rs | 103 | ||||
| -rw-r--r-- | vendor/serde_json/src/value/ser.rs | 1053 |
6 files changed, 0 insertions, 4120 deletions
diff --git a/vendor/serde_json/src/value/de.rs b/vendor/serde_json/src/value/de.rs deleted file mode 100644 index 1e8b5ac..0000000 --- a/vendor/serde_json/src/value/de.rs +++ /dev/null @@ -1,1419 +0,0 @@ -use crate::error::{Error, ErrorCode}; -use crate::map::Map; -use crate::number::Number; -use crate::value::Value; -use alloc::borrow::{Cow, ToOwned}; -use alloc::string::String; -#[cfg(feature = "raw_value")] -use alloc::string::ToString; -use alloc::vec::{self, Vec}; -use core::fmt; -use core::slice; -use core::str::FromStr; -use serde::de::{ - self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, - SeqAccess, Unexpected, VariantAccess, Visitor, -}; -use serde::forward_to_deserialize_any; - -#[cfg(feature = "arbitrary_precision")] -use crate::number::NumberFromString; - -impl<'de> Deserialize<'de> for Value { - #[inline] - fn deserialize<D>(deserializer: D) -> Result<Value, D::Error> - where - D: serde::Deserializer<'de>, - { - struct ValueVisitor; - - impl<'de> Visitor<'de> 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)) - } - - #[cfg(any(feature = "std", feature = "alloc"))] - #[inline] - fn visit_str<E>(self, value: &str) -> Result<Value, E> - where - E: serde::de::Error, - { - self.visit_string(String::from(value)) - } - - #[cfg(any(feature = "std", feature = "alloc"))] - #[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: serde::Deserializer<'de>, - { - Deserialize::deserialize(deserializer) - } - - #[inline] - fn visit_unit<E>(self) -> Result<Value, E> { - Ok(Value::Null) - } - - #[inline] - fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error> - where - V: SeqAccess<'de>, - { - let mut vec = Vec::new(); - - while let Some(elem) = tri!(visitor.next_element()) { - vec.push(elem); - } - - Ok(Value::Array(vec)) - } - - #[cfg(any(feature = "std", feature = "alloc"))] - fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error> - where - V: MapAccess<'de>, - { - match tri!(visitor.next_key_seed(KeyClassifier)) { - #[cfg(feature = "arbitrary_precision")] - Some(KeyClass::Number) => { - let number: NumberFromString = tri!(visitor.next_value()); - Ok(Value::Number(number.value)) - } - #[cfg(feature = "raw_value")] - Some(KeyClass::RawValue) => { - let value = tri!(visitor.next_value_seed(crate::raw::BoxedFromString)); - crate::from_str(value.get()).map_err(de::Error::custom) - } - Some(KeyClass::Map(first_key)) => { - let mut values = Map::new(); - - values.insert(first_key, tri!(visitor.next_value())); - while let Some((key, value)) = tri!(visitor.next_entry()) { - values.insert(key, value); - } - - Ok(Value::Object(values)) - } - None => Ok(Value::Object(Map::new())), - } - } - } - - deserializer.deserialize_any(ValueVisitor) - } -} - -impl FromStr for Value { - type Err = Error; - fn from_str(s: &str) -> Result<Value, Error> { - super::super::de::from_str(s) - } -} - -macro_rules! deserialize_number { - ($method:ident) => { - #[cfg(not(feature = "arbitrary_precision"))] - fn $method<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Number(n) => n.deserialize_any(visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - #[cfg(feature = "arbitrary_precision")] - fn $method<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Number(n) => n.$method(visitor), - _ => self.deserialize_any(visitor), - } - } - }; -} - -fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error> -where - V: Visitor<'de>, -{ - let len = array.len(); - let mut deserializer = SeqDeserializer::new(array); - let seq = tri!(visitor.visit_seq(&mut deserializer)); - let remaining = deserializer.iter.len(); - if remaining == 0 { - Ok(seq) - } else { - Err(serde::de::Error::invalid_length( - len, - &"fewer elements in array", - )) - } -} - -fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error> -where - V: Visitor<'de>, -{ - let len = object.len(); - let mut deserializer = MapDeserializer::new(object); - let map = tri!(visitor.visit_map(&mut deserializer)); - let remaining = deserializer.iter.len(); - if remaining == 0 { - Ok(map) - } else { - Err(serde::de::Error::invalid_length( - len, - &"fewer elements in map", - )) - } -} - -impl<'de> serde::Deserializer<'de> for Value { - type Error = Error; - - #[inline] - fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Null => visitor.visit_unit(), - Value::Bool(v) => visitor.visit_bool(v), - Value::Number(n) => n.deserialize_any(visitor), - #[cfg(any(feature = "std", feature = "alloc"))] - Value::String(v) => visitor.visit_string(v), - Value::Array(v) => visit_array(v, visitor), - Value::Object(v) => visit_object(v, visitor), - } - } - - deserialize_number!(deserialize_i8); - deserialize_number!(deserialize_i16); - deserialize_number!(deserialize_i32); - deserialize_number!(deserialize_i64); - deserialize_number!(deserialize_i128); - deserialize_number!(deserialize_u8); - deserialize_number!(deserialize_u16); - deserialize_number!(deserialize_u32); - deserialize_number!(deserialize_u64); - deserialize_number!(deserialize_u128); - deserialize_number!(deserialize_f32); - deserialize_number!(deserialize_f64); - - #[inline] - fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - 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: Visitor<'de>, - { - 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(serde::de::Error::invalid_value( - Unexpected::Map, - &"map with a single key", - )); - } - }; - // enums are encoded in json as maps with a single key:value pair - if iter.next().is_some() { - return Err(serde::de::Error::invalid_value( - Unexpected::Map, - &"map with a single key", - )); - } - (variant, Some(value)) - } - Value::String(variant) => (variant, None), - other => { - return Err(serde::de::Error::invalid_type( - other.unexpected(), - &"string or map", - )); - } - }; - - visitor.visit_enum(EnumDeserializer { variant, value }) - } - - #[inline] - fn deserialize_newtype_struct<V>( - self, - name: &'static str, - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - #[cfg(feature = "raw_value")] - { - if name == crate::raw::TOKEN { - return visitor.visit_map(crate::raw::OwnedRawDeserializer { - raw_value: Some(self.to_string()), - }); - } - } - - let _ = name; - visitor.visit_newtype_struct(self) - } - - fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Bool(v) => visitor.visit_bool(v), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_string(visitor) - } - - fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_string(visitor) - } - - fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - #[cfg(any(feature = "std", feature = "alloc"))] - Value::String(v) => visitor.visit_string(v), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_byte_buf(visitor) - } - - fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - #[cfg(any(feature = "std", feature = "alloc"))] - Value::String(v) => visitor.visit_string(v), - Value::Array(v) => visit_array(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Null => visitor.visit_unit(), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_unit(visitor) - } - - fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Array(v) => visit_array(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_seq(visitor) - } - - fn deserialize_tuple_struct<V>( - self, - _name: &'static str, - _len: usize, - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_seq(visitor) - } - - fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Object(v) => visit_object(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_struct<V>( - self, - _name: &'static str, - _fields: &'static [&'static str], - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Array(v) => visit_array(v, visitor), - Value::Object(v) => visit_object(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_string(visitor) - } - - fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - drop(self); - visitor.visit_unit() - } -} - -struct EnumDeserializer { - variant: String, - value: Option<Value>, -} - -impl<'de> EnumAccess<'de> for EnumDeserializer { - type Error = Error; - type Variant = VariantDeserializer; - - fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error> - where - V: DeserializeSeed<'de>, - { - let variant = self.variant.into_deserializer(); - let visitor = VariantDeserializer { value: self.value }; - seed.deserialize(variant).map(|v| (v, visitor)) - } -} - -impl<'de> IntoDeserializer<'de, Error> for Value { - type Deserializer = Self; - - fn into_deserializer(self) -> Self::Deserializer { - self - } -} - -impl<'de> IntoDeserializer<'de, Error> for &'de Value { - type Deserializer = Self; - - fn into_deserializer(self) -> Self::Deserializer { - self - } -} - -struct VariantDeserializer { - value: Option<Value>, -} - -impl<'de> VariantAccess<'de> for VariantDeserializer { - type Error = Error; - - fn unit_variant(self) -> Result<(), Error> { - match self.value { - Some(value) => Deserialize::deserialize(value), - None => Ok(()), - } - } - - fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error> - where - T: DeserializeSeed<'de>, - { - match self.value { - Some(value) => seed.deserialize(value), - None => Err(serde::de::Error::invalid_type( - Unexpected::UnitVariant, - &"newtype variant", - )), - } - } - - fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self.value { - Some(Value::Array(v)) => { - if v.is_empty() { - visitor.visit_unit() - } else { - visit_array(v, visitor) - } - } - Some(other) => Err(serde::de::Error::invalid_type( - other.unexpected(), - &"tuple variant", - )), - None => Err(serde::de::Error::invalid_type( - Unexpected::UnitVariant, - &"tuple variant", - )), - } - } - - fn struct_variant<V>( - self, - _fields: &'static [&'static str], - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self.value { - Some(Value::Object(v)) => visit_object(v, visitor), - Some(other) => Err(serde::de::Error::invalid_type( - other.unexpected(), - &"struct variant", - )), - None => Err(serde::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> SeqAccess<'de> for SeqDeserializer { - type Error = Error; - - fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> - where - T: DeserializeSeed<'de>, - { - match self.iter.next() { - Some(value) => seed.deserialize(value).map(Some), - None => Ok(None), - } - } - - fn size_hint(&self) -> Option<usize> { - match self.iter.size_hint() { - (lower, Some(upper)) if lower == upper => Some(upper), - _ => None, - } - } -} - -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> MapAccess<'de> for MapDeserializer { - type Error = Error; - - fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> - where - T: DeserializeSeed<'de>, - { - match self.iter.next() { - Some((key, value)) => { - self.value = Some(value); - let key_de = MapKeyDeserializer { - key: Cow::Owned(key), - }; - seed.deserialize(key_de).map(Some) - } - None => Ok(None), - } - } - - fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error> - where - T: DeserializeSeed<'de>, - { - match self.value.take() { - Some(value) => seed.deserialize(value), - None => Err(serde::de::Error::custom("value is missing")), - } - } - - fn size_hint(&self) -> Option<usize> { - match self.iter.size_hint() { - (lower, Some(upper)) if lower == upper => Some(upper), - _ => None, - } - } -} - -macro_rules! deserialize_value_ref_number { - ($method:ident) => { - #[cfg(not(feature = "arbitrary_precision"))] - fn $method<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Number(n) => n.deserialize_any(visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - #[cfg(feature = "arbitrary_precision")] - fn $method<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Number(n) => n.$method(visitor), - _ => self.deserialize_any(visitor), - } - } - }; -} - -fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error> -where - V: Visitor<'de>, -{ - let len = array.len(); - let mut deserializer = SeqRefDeserializer::new(array); - let seq = tri!(visitor.visit_seq(&mut deserializer)); - let remaining = deserializer.iter.len(); - if remaining == 0 { - Ok(seq) - } else { - Err(serde::de::Error::invalid_length( - len, - &"fewer elements in array", - )) - } -} - -fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error> -where - V: Visitor<'de>, -{ - let len = object.len(); - let mut deserializer = MapRefDeserializer::new(object); - let map = tri!(visitor.visit_map(&mut deserializer)); - let remaining = deserializer.iter.len(); - if remaining == 0 { - Ok(map) - } else { - Err(serde::de::Error::invalid_length( - len, - &"fewer elements in map", - )) - } -} - -impl<'de> serde::Deserializer<'de> for &'de Value { - type Error = Error; - - fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Null => visitor.visit_unit(), - Value::Bool(v) => visitor.visit_bool(*v), - Value::Number(n) => n.deserialize_any(visitor), - Value::String(v) => visitor.visit_borrowed_str(v), - Value::Array(v) => visit_array_ref(v, visitor), - Value::Object(v) => visit_object_ref(v, visitor), - } - } - - deserialize_value_ref_number!(deserialize_i8); - deserialize_value_ref_number!(deserialize_i16); - deserialize_value_ref_number!(deserialize_i32); - deserialize_value_ref_number!(deserialize_i64); - deserialize_number!(deserialize_i128); - deserialize_value_ref_number!(deserialize_u8); - deserialize_value_ref_number!(deserialize_u16); - deserialize_value_ref_number!(deserialize_u32); - deserialize_value_ref_number!(deserialize_u64); - deserialize_number!(deserialize_u128); - deserialize_value_ref_number!(deserialize_f32); - deserialize_value_ref_number!(deserialize_f64); - - fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - 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: Visitor<'de>, - { - 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(serde::de::Error::invalid_value( - Unexpected::Map, - &"map with a single key", - )); - } - }; - // enums are encoded in json as maps with a single key:value pair - if iter.next().is_some() { - return Err(serde::de::Error::invalid_value( - Unexpected::Map, - &"map with a single key", - )); - } - (variant, Some(value)) - } - Value::String(variant) => (variant, None), - other => { - return Err(serde::de::Error::invalid_type( - other.unexpected(), - &"string or map", - )); - } - }; - - visitor.visit_enum(EnumRefDeserializer { variant, value }) - } - - #[inline] - fn deserialize_newtype_struct<V>( - self, - name: &'static str, - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - #[cfg(feature = "raw_value")] - { - if name == crate::raw::TOKEN { - return visitor.visit_map(crate::raw::OwnedRawDeserializer { - raw_value: Some(self.to_string()), - }); - } - } - - let _ = name; - visitor.visit_newtype_struct(self) - } - - fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match *self { - Value::Bool(v) => visitor.visit_bool(v), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_str(visitor) - } - - fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::String(v) => visitor.visit_borrowed_str(v), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_str(visitor) - } - - fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::String(v) => visitor.visit_borrowed_str(v), - Value::Array(v) => visit_array_ref(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_bytes(visitor) - } - - fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match *self { - Value::Null => visitor.visit_unit(), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_unit(visitor) - } - - fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Array(v) => visit_array_ref(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_seq(visitor) - } - - fn deserialize_tuple_struct<V>( - self, - _name: &'static str, - _len: usize, - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_seq(visitor) - } - - fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Object(v) => visit_object_ref(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_struct<V>( - self, - _name: &'static str, - _fields: &'static [&'static str], - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self { - Value::Array(v) => visit_array_ref(v, visitor), - Value::Object(v) => visit_object_ref(v, visitor), - _ => Err(self.invalid_type(&visitor)), - } - } - - fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.deserialize_str(visitor) - } - - fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - visitor.visit_unit() - } -} - -struct EnumRefDeserializer<'de> { - variant: &'de str, - value: Option<&'de Value>, -} - -impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> { - type Error = Error; - type Variant = VariantRefDeserializer<'de>; - - fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error> - where - V: DeserializeSeed<'de>, - { - let variant = self.variant.into_deserializer(); - let visitor = VariantRefDeserializer { value: self.value }; - seed.deserialize(variant).map(|v| (v, visitor)) - } -} - -struct VariantRefDeserializer<'de> { - value: Option<&'de Value>, -} - -impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> { - type Error = Error; - - fn unit_variant(self) -> Result<(), Error> { - match self.value { - Some(value) => Deserialize::deserialize(value), - None => Ok(()), - } - } - - fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error> - where - T: DeserializeSeed<'de>, - { - match self.value { - Some(value) => seed.deserialize(value), - None => Err(serde::de::Error::invalid_type( - Unexpected::UnitVariant, - &"newtype variant", - )), - } - } - - fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self.value { - Some(Value::Array(v)) => { - if v.is_empty() { - visitor.visit_unit() - } else { - visit_array_ref(v, visitor) - } - } - Some(other) => Err(serde::de::Error::invalid_type( - other.unexpected(), - &"tuple variant", - )), - None => Err(serde::de::Error::invalid_type( - Unexpected::UnitVariant, - &"tuple variant", - )), - } - } - - fn struct_variant<V>( - self, - _fields: &'static [&'static str], - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - match self.value { - Some(Value::Object(v)) => visit_object_ref(v, visitor), - Some(other) => Err(serde::de::Error::invalid_type( - other.unexpected(), - &"struct variant", - )), - None => Err(serde::de::Error::invalid_type( - Unexpected::UnitVariant, - &"struct variant", - )), - } - } -} - -struct SeqRefDeserializer<'de> { - iter: slice::Iter<'de, Value>, -} - -impl<'de> SeqRefDeserializer<'de> { - fn new(slice: &'de [Value]) -> Self { - SeqRefDeserializer { iter: slice.iter() } - } -} - -impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> { - type Error = Error; - - fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> - where - T: DeserializeSeed<'de>, - { - match self.iter.next() { - Some(value) => seed.deserialize(value).map(Some), - None => Ok(None), - } - } - - fn size_hint(&self) -> Option<usize> { - match self.iter.size_hint() { - (lower, Some(upper)) if lower == upper => Some(upper), - _ => None, - } - } -} - -struct MapRefDeserializer<'de> { - iter: <&'de Map<String, Value> as IntoIterator>::IntoIter, - value: Option<&'de Value>, -} - -impl<'de> MapRefDeserializer<'de> { - fn new(map: &'de Map<String, Value>) -> Self { - MapRefDeserializer { - iter: map.into_iter(), - value: None, - } - } -} - -impl<'de> MapAccess<'de> for MapRefDeserializer<'de> { - type Error = Error; - - fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> - where - T: DeserializeSeed<'de>, - { - match self.iter.next() { - Some((key, value)) => { - self.value = Some(value); - let key_de = MapKeyDeserializer { - key: Cow::Borrowed(&**key), - }; - seed.deserialize(key_de).map(Some) - } - None => Ok(None), - } - } - - fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error> - where - T: DeserializeSeed<'de>, - { - match self.value.take() { - Some(value) => seed.deserialize(value), - None => Err(serde::de::Error::custom("value is missing")), - } - } - - fn size_hint(&self) -> Option<usize> { - match self.iter.size_hint() { - (lower, Some(upper)) if lower == upper => Some(upper), - _ => None, - } - } -} - -struct MapKeyDeserializer<'de> { - key: Cow<'de, str>, -} - -macro_rules! deserialize_numeric_key { - ($method:ident) => { - deserialize_numeric_key!($method, deserialize_number); - }; - - ($method:ident, $using:ident) => { - fn $method<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - let mut de = crate::Deserializer::from_str(&self.key); - - match tri!(de.peek()) { - Some(b'0'..=b'9' | b'-') => {} - _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)), - } - - let number = tri!(de.$using(visitor)); - - if tri!(de.peek()).is_some() { - return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)); - } - - Ok(number) - } - }; -} - -impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> { - type Error = Error; - - fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor) - } - - deserialize_numeric_key!(deserialize_i8); - deserialize_numeric_key!(deserialize_i16); - deserialize_numeric_key!(deserialize_i32); - deserialize_numeric_key!(deserialize_i64); - deserialize_numeric_key!(deserialize_u8); - deserialize_numeric_key!(deserialize_u16); - deserialize_numeric_key!(deserialize_u32); - deserialize_numeric_key!(deserialize_u64); - #[cfg(not(feature = "float_roundtrip"))] - deserialize_numeric_key!(deserialize_f32); - deserialize_numeric_key!(deserialize_f64); - - #[cfg(feature = "float_roundtrip")] - deserialize_numeric_key!(deserialize_f32, do_deserialize_f32); - deserialize_numeric_key!(deserialize_i128, do_deserialize_i128); - deserialize_numeric_key!(deserialize_u128, do_deserialize_u128); - - fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - if self.key == "true" { - visitor.visit_bool(true) - } else if self.key == "false" { - visitor.visit_bool(false) - } else { - Err(serde::de::Error::invalid_type( - Unexpected::Str(&self.key), - &visitor, - )) - } - } - - #[inline] - fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - // Map keys cannot be null. - visitor.visit_some(self) - } - - #[inline] - fn deserialize_newtype_struct<V>( - self, - _name: &'static str, - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - visitor.visit_newtype_struct(self) - } - - fn deserialize_enum<V>( - self, - name: &'static str, - variants: &'static [&'static str], - visitor: V, - ) -> Result<V::Value, Error> - where - V: Visitor<'de>, - { - self.key - .into_deserializer() - .deserialize_enum(name, variants, visitor) - } - - forward_to_deserialize_any! { - char str string bytes byte_buf unit unit_struct seq tuple tuple_struct - map struct identifier ignored_any - } -} - -struct KeyClassifier; - -enum KeyClass { - Map(String), - #[cfg(feature = "arbitrary_precision")] - Number, - #[cfg(feature = "raw_value")] - RawValue, -} - -impl<'de> DeserializeSeed<'de> for KeyClassifier { - type Value = KeyClass; - - fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> - where - D: serde::Deserializer<'de>, - { - deserializer.deserialize_str(self) - } -} - -impl<'de> Visitor<'de> for KeyClassifier { - type Value = KeyClass; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a string key") - } - - fn visit_str<E>(self, s: &str) -> Result<Self::Value, E> - where - E: de::Error, - { - match s { - #[cfg(feature = "arbitrary_precision")] - crate::number::TOKEN => Ok(KeyClass::Number), - #[cfg(feature = "raw_value")] - crate::raw::TOKEN => Ok(KeyClass::RawValue), - _ => Ok(KeyClass::Map(s.to_owned())), - } - } - - #[cfg(any(feature = "std", feature = "alloc"))] - fn visit_string<E>(self, s: String) -> Result<Self::Value, E> - where - E: de::Error, - { - match s.as_str() { - #[cfg(feature = "arbitrary_precision")] - crate::number::TOKEN => Ok(KeyClass::Number), - #[cfg(feature = "raw_value")] - crate::raw::TOKEN => Ok(KeyClass::RawValue), - _ => Ok(KeyClass::Map(s)), - } - } -} - -impl Value { - #[cold] - fn invalid_type<E>(&self, exp: &dyn Expected) -> E - where - E: serde::de::Error, - { - serde::de::Error::invalid_type(self.unexpected(), exp) - } - - #[cold] - fn unexpected(&self) -> Unexpected { - match self { - Value::Null => Unexpected::Unit, - Value::Bool(b) => Unexpected::Bool(*b), - Value::Number(n) => n.unexpected(), - Value::String(s) => Unexpected::Str(s), - Value::Array(_) => Unexpected::Seq, - Value::Object(_) => Unexpected::Map, - } - } -} - -struct BorrowedCowStrDeserializer<'de> { - value: Cow<'de, str>, -} - -impl<'de> BorrowedCowStrDeserializer<'de> { - fn new(value: Cow<'de, str>) -> Self { - BorrowedCowStrDeserializer { value } - } -} - -impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> { - type Error = Error; - - fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where - V: de::Visitor<'de>, - { - match self.value { - Cow::Borrowed(string) => visitor.visit_borrowed_str(string), - #[cfg(any(feature = "std", feature = "alloc"))] - Cow::Owned(string) => visitor.visit_string(string), - } - } - - fn deserialize_enum<V>( - self, - _name: &str, - _variants: &'static [&'static str], - visitor: V, - ) -> Result<V::Value, Error> - where - V: de::Visitor<'de>, - { - visitor.visit_enum(self) - } - - forward_to_deserialize_any! { - bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string - bytes byte_buf option unit unit_struct newtype_struct seq tuple - tuple_struct map struct identifier ignored_any - } -} - -impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> { - type Error = Error; - type Variant = UnitOnly; - - fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error> - where - T: de::DeserializeSeed<'de>, - { - let value = tri!(seed.deserialize(self)); - Ok((value, UnitOnly)) - } -} - -struct UnitOnly; - -impl<'de> de::VariantAccess<'de> for UnitOnly { - type Error = Error; - - fn unit_variant(self) -> Result<(), Error> { - Ok(()) - } - - fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error> - where - T: de::DeserializeSeed<'de>, - { - Err(de::Error::invalid_type( - Unexpected::UnitVariant, - &"newtype variant", - )) - } - - fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error> - where - V: de::Visitor<'de>, - { - Err(de::Error::invalid_type( - Unexpected::UnitVariant, - &"tuple variant", - )) - } - - fn struct_variant<V>( - self, - _fields: &'static [&'static str], - _visitor: V, - ) -> Result<V::Value, Error> - where - V: de::Visitor<'de>, - { - Err(de::Error::invalid_type( - Unexpected::UnitVariant, - &"struct variant", - )) - } -} diff --git a/vendor/serde_json/src/value/from.rs b/vendor/serde_json/src/value/from.rs deleted file mode 100644 index ed1e333..0000000 --- a/vendor/serde_json/src/value/from.rs +++ /dev/null @@ -1,278 +0,0 @@ -use super::Value; -use crate::map::Map; -use crate::number::Number; -use alloc::borrow::Cow; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; - -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 -} - -#[cfg(feature = "arbitrary_precision")] -from_integer! { - i128 u128 -} - -impl From<f32> for Value { - /// Convert 32-bit floating point number to `Value::Number`, or - /// `Value::Null` if infinite or NaN. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let f: f32 = 13.37; - /// let x: Value = f.into(); - /// ``` - fn from(f: f32) -> Self { - Number::from_f32(f).map_or(Value::Null, Value::Number) - } -} - -impl From<f64> for Value { - /// Convert 64-bit floating point number to `Value::Number`, or - /// `Value::Null` if infinite or NaN. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let f: f64 = 13.37; - /// let x: Value = f.into(); - /// ``` - fn from(f: f64) -> Self { - Number::from_f64(f).map_or(Value::Null, Value::Number) - } -} - -impl From<bool> for Value { - /// Convert boolean to `Value::Bool`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let b = false; - /// let x: Value = b.into(); - /// ``` - fn from(f: bool) -> Self { - Value::Bool(f) - } -} - -impl From<String> for Value { - /// Convert `String` to `Value::String`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let s: String = "lorem".to_string(); - /// let x: Value = s.into(); - /// ``` - fn from(f: String) -> Self { - Value::String(f) - } -} - -impl From<&str> for Value { - /// Convert string slice to `Value::String`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let s: &str = "lorem"; - /// let x: Value = s.into(); - /// ``` - fn from(f: &str) -> Self { - Value::String(f.to_string()) - } -} - -impl<'a> From<Cow<'a, str>> for Value { - /// Convert copy-on-write string to `Value::String`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// use std::borrow::Cow; - /// - /// let s: Cow<str> = Cow::Borrowed("lorem"); - /// let x: Value = s.into(); - /// ``` - /// - /// ``` - /// use serde_json::Value; - /// use std::borrow::Cow; - /// - /// let s: Cow<str> = Cow::Owned("lorem".to_string()); - /// let x: Value = s.into(); - /// ``` - fn from(f: Cow<'a, str>) -> Self { - Value::String(f.into_owned()) - } -} - -impl From<Number> for Value { - /// Convert `Number` to `Value::Number`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::{Number, Value}; - /// - /// let n = Number::from(7); - /// let x: Value = n.into(); - /// ``` - fn from(f: Number) -> Self { - Value::Number(f) - } -} - -impl From<Map<String, Value>> for Value { - /// Convert map (with string keys) to `Value::Object`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::{Map, Value}; - /// - /// let mut m = Map::new(); - /// m.insert("Lorem".to_string(), "ipsum".into()); - /// let x: Value = m.into(); - /// ``` - fn from(f: Map<String, Value>) -> Self { - Value::Object(f) - } -} - -impl<T: Into<Value>> From<Vec<T>> for Value { - /// Convert a `Vec` to `Value::Array`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let v = vec!["lorem", "ipsum", "dolor"]; - /// let x: Value = v.into(); - /// ``` - fn from(f: Vec<T>) -> Self { - Value::Array(f.into_iter().map(Into::into).collect()) - } -} - -impl<T: Clone + Into<Value>> From<&[T]> for Value { - /// Convert a slice to `Value::Array`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let v: &[&str] = &["lorem", "ipsum", "dolor"]; - /// let x: Value = v.into(); - /// ``` - fn from(f: &[T]) -> Self { - Value::Array(f.iter().cloned().map(Into::into).collect()) - } -} - -impl<T: Into<Value>> FromIterator<T> for Value { - /// Create a `Value::Array` by collecting an iterator of array elements. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let v = std::iter::repeat(42).take(5); - /// let x: Value = v.collect(); - /// ``` - /// - /// ``` - /// use serde_json::Value; - /// - /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"]; - /// let x: Value = v.into_iter().collect(); - /// ``` - /// - /// ``` - /// use std::iter::FromIterator; - /// use serde_json::Value; - /// - /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]); - /// ``` - fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self { - Value::Array(iter.into_iter().map(Into::into).collect()) - } -} - -impl<K: Into<String>, V: Into<Value>> FromIterator<(K, V)> for Value { - /// Create a `Value::Object` by collecting an iterator of key-value pairs. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)]; - /// let x: Value = v.into_iter().collect(); - /// ``` - fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self { - Value::Object( - iter.into_iter() - .map(|(k, v)| (k.into(), v.into())) - .collect(), - ) - } -} - -impl From<()> for Value { - /// Convert `()` to `Value::Null`. - /// - /// # Examples - /// - /// ``` - /// use serde_json::Value; - /// - /// let u = (); - /// let x: Value = u.into(); - /// ``` - fn from((): ()) -> Self { - Value::Null - } -} - -impl<T> From<Option<T>> for Value -where - T: Into<Value>, -{ - fn from(opt: Option<T>) -> Self { - match opt { - None => Value::Null, - Some(value) => Into::into(value), - } - } -} diff --git a/vendor/serde_json/src/value/index.rs b/vendor/serde_json/src/value/index.rs deleted file mode 100644 index 891ca8e..0000000 --- a/vendor/serde_json/src/value/index.rs +++ /dev/null @@ -1,258 +0,0 @@ -use super::Value; -use crate::map::Map; -use alloc::borrow::ToOwned; -use alloc::string::String; -use core::fmt::{self, Display}; -use core::ops; - -/// A type that can be used to index into a `serde_json::Value`. -/// -/// The [`get`] and [`get_mut`] methods of `Value` accept any type that -/// implements `Index`, as does the [square-bracket indexing operator]. This -/// trait is implemented for strings which are used as the index into a JSON -/// map, and for `usize` which is used as the index into a JSON array. -/// -/// [`get`]: ../enum.Value.html#method.get -/// [`get_mut`]: ../enum.Value.html#method.get_mut -/// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E -/// -/// This trait is sealed and cannot be implemented for types outside of -/// `serde_json`. -/// -/// # Examples -/// -/// ``` -/// # use serde_json::json; -/// # -/// let data = json!({ "inner": [1, 2, 3] }); -/// -/// // Data is a JSON map so it can be indexed with a string. -/// let inner = &data["inner"]; -/// -/// // Inner is a JSON array so it can be indexed with an integer. -/// let first = &inner[0]; -/// -/// assert_eq!(first, 1); -/// ``` -pub trait Index: private::Sealed { - /// Return None if the key is not already in the array or object. - #[doc(hidden)] - fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>; - - /// Return None if the key is not already in the array or object. - #[doc(hidden)] - fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>; - - /// Panic if array index out of bounds. If key is not already in the object, - /// insert it with a value of null. Panic if Value is a type that cannot be - /// indexed into, except if Value is null then it can be treated as an empty - /// object. - #[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(vec) => vec.get(*self), - _ => None, - } - } - fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> { - match v { - Value::Array(vec) => vec.get_mut(*self), - _ => None, - } - } - fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value { - match v { - Value::Array(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(map) => map.get(self), - _ => None, - } - } - fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> { - match v { - Value::Object(map) => map.get_mut(self), - _ => None, - } - } - fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value { - if let Value::Null = v { - *v = Value::Object(Map::new()); - } - match v { - Value::Object(map) => map.entry(self.to_owned()).or_insert(Value::Null), - _ => 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<T> Index for &T -where - T: ?Sized + 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) - } -} - -// Prevent users from implementing the Index trait. -mod private { - pub trait Sealed {} - impl Sealed for usize {} - impl Sealed for str {} - impl Sealed for alloc::string::String {} - impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {} -} - -/// Used in panic messages. -struct Type<'a>(&'a Value); - -impl<'a> 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"), - } - } -} - -// The usual semantics of Index is to panic on invalid indexing. -// -// That said, the usual semantics are for things like Vec and BTreeMap which -// have different use cases than Value. If you are working with a Vec, you know -// that you are working with a Vec and you can get the len of the Vec and make -// sure your indices are within bounds. The Value use cases are more -// loosey-goosey. You got some JSON from an endpoint and you want to pull values -// out of it. Outside of this Index impl, you already have the option of using -// value.as_array() and working with the Vec directly, or matching on -// Value::Array and getting the Vec directly. The Index impl means you can skip -// that and index directly into the thing using a concise syntax. You don't have -// to check the type, you don't have to check the len, it is all about what you -// expect the Value to look like. -// -// Basically the use cases that would be well served by panicking here are -// better served by using one of the other approaches: get and get_mut, -// as_array, or match. The value of this impl is that it adds a way of working -// with Value that is not well served by the existing approaches: concise and -// careless and sometimes that is exactly what you want. -impl<I> ops::Index<I> for Value -where - I: Index, -{ - type Output = Value; - - /// Index into a `serde_json::Value` using the syntax `value[0]` or - /// `value["k"]`. - /// - /// Returns `Value::Null` if the type of `self` does not match the type of - /// the index, for example if the index is a string and `self` is an array - /// or a number. Also returns `Value::Null` if the given key does not exist - /// in the map or the given index is not within the bounds of the array. - /// - /// For retrieving deeply nested values, you should have a look at the - /// `Value::pointer` method. - /// - /// # Examples - /// - /// ``` - /// # use serde_json::json; - /// # - /// let data = json!({ - /// "x": { - /// "y": ["z", "zz"] - /// } - /// }); - /// - /// assert_eq!(data["x"]["y"], json!(["z", "zz"])); - /// assert_eq!(data["x"]["y"][0], json!("z")); - /// - /// assert_eq!(data["a"], json!(null)); // returns null for undefined values - /// assert_eq!(data["a"]["b"], json!(null)); // does not panic - /// ``` - 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, -{ - /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or - /// `value["k"] = ...`. - /// - /// If the index is a number, the value must be an array of length bigger - /// than the index. Indexing into a value that is not an array or an array - /// that is too small will panic. - /// - /// If the index is a string, the value must be an object or null which is - /// treated like an empty object. If the key is not already present in the - /// object, it will be inserted with a value of null. Indexing into a value - /// that is neither an object nor null will panic. - /// - /// # Examples - /// - /// ``` - /// # use serde_json::json; - /// # - /// let mut data = json!({ "x": 0 }); - /// - /// // replace an existing key - /// data["x"] = json!(1); - /// - /// // insert a new key - /// data["y"] = json!([false, false, false]); - /// - /// // replace an array value - /// data["y"][0] = json!(true); - /// - /// // inserted a deeply nested key - /// data["a"]["b"]["c"]["d"] = json!(true); - /// - /// println!("{}", data); - /// ``` - fn index_mut(&mut self, index: I) -> &mut Value { - index.index_or_insert(self) - } -} diff --git a/vendor/serde_json/src/value/mod.rs b/vendor/serde_json/src/value/mod.rs deleted file mode 100644 index b3f51ea..0000000 --- a/vendor/serde_json/src/value/mod.rs +++ /dev/null @@ -1,1009 +0,0 @@ -//! The Value enum, a loosely typed way of representing any valid JSON value. -//! -//! # Constructing JSON -//! -//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value` -//! objects with very natural JSON syntax. -//! -//! ``` -//! use serde_json::json; -//! -//! fn main() { -//! // The type of `john` is `serde_json::Value` -//! let john = json!({ -//! "name": "John Doe", -//! "age": 43, -//! "phones": [ -//! "+44 1234567", -//! "+44 2345678" -//! ] -//! }); -//! -//! println!("first phone number: {}", john["phones"][0]); -//! -//! // Convert to a string of JSON and print it out -//! println!("{}", john.to_string()); -//! } -//! ``` -//! -//! The `Value::to_string()` function converts a `serde_json::Value` into a -//! `String` of JSON text. -//! -//! One neat thing about the `json!` macro is that variables and expressions can -//! be interpolated directly into the JSON value as you are building it. Serde -//! will check at compile time that the value you are interpolating is able to -//! be represented as JSON. -//! -//! ``` -//! # use serde_json::json; -//! # -//! # fn random_phone() -> u16 { 0 } -//! # -//! let full_name = "John Doe"; -//! let age_last_year = 42; -//! -//! // The type of `john` is `serde_json::Value` -//! let john = json!({ -//! "name": full_name, -//! "age": age_last_year + 1, -//! "phones": [ -//! format!("+44 {}", random_phone()) -//! ] -//! }); -//! ``` -//! -//! A string of JSON data can be parsed into a `serde_json::Value` by the -//! [`serde_json::from_str`][from_str] function. There is also -//! [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` and -//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or -//! a TCP stream. -//! -//! ``` -//! use serde_json::{json, Value, Error}; -//! -//! fn untyped_example() -> Result<(), Error> { -//! // Some JSON input data as a &str. Maybe this comes from the user. -//! let data = r#" -//! { -//! "name": "John Doe", -//! "age": 43, -//! "phones": [ -//! "+44 1234567", -//! "+44 2345678" -//! ] -//! }"#; -//! -//! // Parse the string of data into serde_json::Value. -//! let v: Value = serde_json::from_str(data)?; -//! -//! // Access parts of the data by indexing with square brackets. -//! println!("Please call {} at the number {}", v["name"], v["phones"][0]); -//! -//! Ok(()) -//! } -//! # -//! # untyped_example().unwrap(); -//! ``` -//! -//! [macro]: crate::json -//! [from_str]: crate::de::from_str -//! [from_slice]: crate::de::from_slice -//! [from_reader]: crate::de::from_reader - -use crate::error::Error; -use crate::io; -use alloc::string::String; -use alloc::vec::Vec; -use core::fmt::{self, Debug, Display}; -use core::mem; -use core::str; -use serde::de::DeserializeOwned; -use serde::ser::Serialize; - -pub use self::index::Index; -pub use self::ser::Serializer; -pub use crate::map::Map; -pub use crate::number::Number; - -#[cfg(feature = "raw_value")] -#[cfg_attr(docsrs, doc(cfg(feature = "raw_value")))] -pub use crate::raw::{to_raw_value, RawValue}; - -/// Represents any valid JSON value. -/// -/// See the [`serde_json::value` module documentation](self) for usage examples. -#[derive(Clone, Eq, PartialEq)] -pub enum Value { - /// Represents a JSON null value. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!(null); - /// ``` - Null, - - /// Represents a JSON boolean. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!(true); - /// ``` - Bool(bool), - - /// Represents a JSON number, whether integer or floating point. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!(12.5); - /// ``` - Number(Number), - - /// Represents a JSON string. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!("a string"); - /// ``` - String(String), - - /// Represents a JSON array. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!(["an", "array"]); - /// ``` - Array(Vec<Value>), - - /// Represents a JSON object. - /// - /// By default the map is backed by a BTreeMap. Enable the `preserve_order` - /// feature of serde_json to use IndexMap instead, which preserves - /// entries in the order they are inserted into the map. In particular, this - /// allows JSON data to be deserialized into a Value and serialized to a - /// string while retaining the order of map keys in the input. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "an": "object" }); - /// ``` - Object(Map<String, Value>), -} - -impl Debug for Value { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - match self { - Value::Null => formatter.write_str("Null"), - Value::Bool(boolean) => write!(formatter, "Bool({})", boolean), - Value::Number(number) => Debug::fmt(number, formatter), - Value::String(string) => write!(formatter, "String({:?})", string), - Value::Array(vec) => { - tri!(formatter.write_str("Array ")); - Debug::fmt(vec, formatter) - } - Value::Object(map) => { - tri!(formatter.write_str("Object ")); - Debug::fmt(map, formatter) - } - } - } -} - -impl Display for Value { - /// Display a JSON value as a string. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let json = json!({ "city": "London", "street": "10 Downing Street" }); - /// - /// // Compact format: - /// // - /// // {"city":"London","street":"10 Downing Street"} - /// let compact = format!("{}", json); - /// assert_eq!(compact, - /// "{\"city\":\"London\",\"street\":\"10 Downing Street\"}"); - /// - /// // Pretty format: - /// // - /// // { - /// // "city": "London", - /// // "street": "10 Downing Street" - /// // } - /// let pretty = format!("{:#}", json); - /// assert_eq!(pretty, - /// "{\n \"city\": \"London\",\n \"street\": \"10 Downing Street\"\n}"); - /// ``` - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - 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> { - // Safety: the serializer below only emits valid utf8 when using - // the default formatter. - let s = unsafe { str::from_utf8_unchecked(buf) }; - tri!(self.inner.write_str(s).map_err(io_error)); - Ok(buf.len()) - } - - fn flush(&mut self) -> io::Result<()> { - Ok(()) - } - } - - fn io_error(_: fmt::Error) -> io::Error { - // Error value does not matter because Display impl just maps it - // back to fmt::Error. - io::Error::new(io::ErrorKind::Other, "fmt error") - } - - 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) - } - } -} - -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 { - /// Index into a JSON array or map. A string index can be used to access a - /// value in a map, and a usize index can be used to access an element of an - /// array. - /// - /// Returns `None` if the type of `self` does not match the type of the - /// index, for example if the index is a string and `self` is an array or a - /// number. Also returns `None` if the given key does not exist in the map - /// or the given index is not within the bounds of the array. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let object = json!({ "A": 65, "B": 66, "C": 67 }); - /// assert_eq!(*object.get("A").unwrap(), json!(65)); - /// - /// let array = json!([ "A", "B", "C" ]); - /// assert_eq!(*array.get(2).unwrap(), json!("C")); - /// - /// assert_eq!(array.get("A"), None); - /// ``` - /// - /// Square brackets can also be used to index into a value in a more concise - /// way. This returns `Value::Null` in cases where `get` would have returned - /// `None`. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let object = json!({ - /// "A": ["a", "á", "à"], - /// "B": ["b", "b́"], - /// "C": ["c", "ć", "ć̣", "ḉ"], - /// }); - /// assert_eq!(object["B"][0], json!("b")); - /// - /// assert_eq!(object["D"], json!(null)); - /// assert_eq!(object[0]["x"]["y"]["z"], json!(null)); - /// ``` - pub fn get<I: Index>(&self, index: I) -> Option<&Value> { - index.index_into(self) - } - - /// Mutably index into a JSON array or map. A string index can be used to - /// access a value in a map, and a usize index can be used to access an - /// element of an array. - /// - /// Returns `None` if the type of `self` does not match the type of the - /// index, for example if the index is a string and `self` is an array or a - /// number. Also returns `None` if the given key does not exist in the map - /// or the given index is not within the bounds of the array. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let mut object = json!({ "A": 65, "B": 66, "C": 67 }); - /// *object.get_mut("A").unwrap() = json!(69); - /// - /// let mut array = json!([ "A", "B", "C" ]); - /// *array.get_mut(2).unwrap() = json!("D"); - /// ``` - pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> { - index.index_into_mut(self) - } - - /// Returns true if the `Value` is an Object. Returns false otherwise. - /// - /// For any Value on which `is_object` returns true, `as_object` and - /// `as_object_mut` are guaranteed to return the map representation of the - /// object. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] }); - /// - /// assert!(obj.is_object()); - /// assert!(obj["a"].is_object()); - /// - /// // array, not an object - /// assert!(!obj["b"].is_object()); - /// ``` - pub fn is_object(&self) -> bool { - self.as_object().is_some() - } - - /// If the `Value` is an Object, returns the associated Map. Returns None - /// otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] }); - /// - /// // The length of `{"nested": true}` is 1 entry. - /// assert_eq!(v["a"].as_object().unwrap().len(), 1); - /// - /// // The array `["an", "array"]` is not an object. - /// assert_eq!(v["b"].as_object(), None); - /// ``` - pub fn as_object(&self) -> Option<&Map<String, Value>> { - match self { - Value::Object(map) => Some(map), - _ => None, - } - } - - /// If the `Value` is an Object, returns the associated mutable Map. - /// Returns None otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let mut v = json!({ "a": { "nested": true } }); - /// - /// v["a"].as_object_mut().unwrap().clear(); - /// assert_eq!(v, json!({ "a": {} })); - /// ``` - pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>> { - match self { - Value::Object(map) => Some(map), - _ => None, - } - } - - /// Returns true if the `Value` is an Array. Returns false otherwise. - /// - /// For any Value on which `is_array` returns true, `as_array` and - /// `as_array_mut` are guaranteed to return the vector representing the - /// array. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } }); - /// - /// assert!(obj["a"].is_array()); - /// - /// // an object, not an array - /// assert!(!obj["b"].is_array()); - /// ``` - pub fn is_array(&self) -> bool { - self.as_array().is_some() - } - - /// If the `Value` is an Array, returns the associated vector. Returns None - /// otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } }); - /// - /// // The length of `["an", "array"]` is 2 elements. - /// assert_eq!(v["a"].as_array().unwrap().len(), 2); - /// - /// // The object `{"an": "object"}` is not an array. - /// assert_eq!(v["b"].as_array(), None); - /// ``` - pub fn as_array(&self) -> Option<&Vec<Value>> { - match self { - Value::Array(array) => Some(array), - _ => None, - } - } - - /// If the `Value` is an Array, returns the associated mutable vector. - /// Returns None otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let mut v = json!({ "a": ["an", "array"] }); - /// - /// v["a"].as_array_mut().unwrap().clear(); - /// assert_eq!(v, json!({ "a": [] })); - /// ``` - pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> { - match self { - Value::Array(list) => Some(list), - _ => None, - } - } - - /// Returns true if the `Value` is a String. Returns false otherwise. - /// - /// For any Value on which `is_string` returns true, `as_str` is guaranteed - /// to return the string slice. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": "some string", "b": false }); - /// - /// assert!(v["a"].is_string()); - /// - /// // The boolean `false` is not a string. - /// assert!(!v["b"].is_string()); - /// ``` - pub fn is_string(&self) -> bool { - self.as_str().is_some() - } - - /// If the `Value` is a String, returns the associated str. Returns None - /// otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": "some string", "b": false }); - /// - /// assert_eq!(v["a"].as_str(), Some("some string")); - /// - /// // The boolean `false` is not a string. - /// assert_eq!(v["b"].as_str(), None); - /// - /// // JSON values are printed in JSON representation, so strings are in quotes. - /// // - /// // The value is: "some string" - /// println!("The value is: {}", v["a"]); - /// - /// // Rust strings are printed without quotes. - /// // - /// // The value is: some string - /// println!("The value is: {}", v["a"].as_str().unwrap()); - /// ``` - pub fn as_str(&self) -> Option<&str> { - match self { - Value::String(s) => Some(s), - _ => None, - } - } - - /// Returns true if the `Value` is a Number. Returns false otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": 1, "b": "2" }); - /// - /// assert!(v["a"].is_number()); - /// - /// // The string `"2"` is a string, not a number. - /// assert!(!v["b"].is_number()); - /// ``` - pub fn is_number(&self) -> bool { - match *self { - Value::Number(_) => true, - _ => false, - } - } - - /// If the `Value` is a Number, returns the associated [`Number`]. Returns - /// None otherwise. - /// - /// ``` - /// # use serde_json::{json, Number}; - /// # - /// let v = json!({ "a": 1, "b": 2.2, "c": -3, "d": "4" }); - /// - /// assert_eq!(v["a"].as_number(), Some(&Number::from(1u64))); - /// assert_eq!(v["b"].as_number(), Some(&Number::from_f64(2.2).unwrap())); - /// assert_eq!(v["c"].as_number(), Some(&Number::from(-3i64))); - /// - /// // The string `"4"` is not a number. - /// assert_eq!(v["d"].as_number(), None); - /// ``` - pub fn as_number(&self) -> Option<&Number> { - match self { - Value::Number(number) => Some(number), - _ => None, - } - } - - /// Returns true if the `Value` is an integer between `i64::MIN` and - /// `i64::MAX`. - /// - /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to - /// return the integer value. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let big = i64::max_value() as u64 + 10; - /// let v = json!({ "a": 64, "b": big, "c": 256.0 }); - /// - /// assert!(v["a"].is_i64()); - /// - /// // Greater than i64::MAX. - /// assert!(!v["b"].is_i64()); - /// - /// // Numbers with a decimal point are not considered integers. - /// assert!(!v["c"].is_i64()); - /// ``` - pub fn is_i64(&self) -> bool { - match self { - Value::Number(n) => n.is_i64(), - _ => false, - } - } - - /// Returns true if the `Value` is an integer between zero and `u64::MAX`. - /// - /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to - /// return the integer value. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": 64, "b": -64, "c": 256.0 }); - /// - /// assert!(v["a"].is_u64()); - /// - /// // Negative integer. - /// assert!(!v["b"].is_u64()); - /// - /// // Numbers with a decimal point are not considered integers. - /// assert!(!v["c"].is_u64()); - /// ``` - pub fn is_u64(&self) -> bool { - match self { - Value::Number(n) => n.is_u64(), - _ => false, - } - } - - /// Returns true if the `Value` is a number that can be represented by f64. - /// - /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to - /// return the floating point value. - /// - /// Currently this function returns true if and only if both `is_i64` and - /// `is_u64` return false but this is not a guarantee in the future. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": 256.0, "b": 64, "c": -64 }); - /// - /// assert!(v["a"].is_f64()); - /// - /// // Integers. - /// assert!(!v["b"].is_f64()); - /// assert!(!v["c"].is_f64()); - /// ``` - pub fn is_f64(&self) -> bool { - match self { - Value::Number(n) => n.is_f64(), - _ => false, - } - } - - /// If the `Value` is an integer, represent it as i64 if possible. Returns - /// None otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let big = i64::max_value() as u64 + 10; - /// let v = json!({ "a": 64, "b": big, "c": 256.0 }); - /// - /// assert_eq!(v["a"].as_i64(), Some(64)); - /// assert_eq!(v["b"].as_i64(), None); - /// assert_eq!(v["c"].as_i64(), None); - /// ``` - pub fn as_i64(&self) -> Option<i64> { - match self { - Value::Number(n) => n.as_i64(), - _ => None, - } - } - - /// If the `Value` is an integer, represent it as u64 if possible. Returns - /// None otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": 64, "b": -64, "c": 256.0 }); - /// - /// assert_eq!(v["a"].as_u64(), Some(64)); - /// assert_eq!(v["b"].as_u64(), None); - /// assert_eq!(v["c"].as_u64(), None); - /// ``` - pub fn as_u64(&self) -> Option<u64> { - match self { - Value::Number(n) => n.as_u64(), - _ => None, - } - } - - /// If the `Value` is a number, represent it as f64 if possible. Returns - /// None otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": 256.0, "b": 64, "c": -64 }); - /// - /// assert_eq!(v["a"].as_f64(), Some(256.0)); - /// assert_eq!(v["b"].as_f64(), Some(64.0)); - /// assert_eq!(v["c"].as_f64(), Some(-64.0)); - /// ``` - pub fn as_f64(&self) -> Option<f64> { - match self { - Value::Number(n) => n.as_f64(), - _ => None, - } - } - - /// Returns true if the `Value` is a Boolean. Returns false otherwise. - /// - /// For any Value on which `is_boolean` returns true, `as_bool` is - /// guaranteed to return the boolean value. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": false, "b": "false" }); - /// - /// assert!(v["a"].is_boolean()); - /// - /// // The string `"false"` is a string, not a boolean. - /// assert!(!v["b"].is_boolean()); - /// ``` - pub fn is_boolean(&self) -> bool { - self.as_bool().is_some() - } - - /// If the `Value` is a Boolean, returns the associated bool. Returns None - /// otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": false, "b": "false" }); - /// - /// assert_eq!(v["a"].as_bool(), Some(false)); - /// - /// // The string `"false"` is a string, not a boolean. - /// assert_eq!(v["b"].as_bool(), None); - /// ``` - pub fn as_bool(&self) -> Option<bool> { - match *self { - Value::Bool(b) => Some(b), - _ => None, - } - } - - /// Returns true if the `Value` is a Null. Returns false otherwise. - /// - /// For any Value on which `is_null` returns true, `as_null` is guaranteed - /// to return `Some(())`. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": null, "b": false }); - /// - /// assert!(v["a"].is_null()); - /// - /// // The boolean `false` is not null. - /// assert!(!v["b"].is_null()); - /// ``` - pub fn is_null(&self) -> bool { - self.as_null().is_some() - } - - /// If the `Value` is a Null, returns (). Returns None otherwise. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let v = json!({ "a": null, "b": false }); - /// - /// assert_eq!(v["a"].as_null(), Some(())); - /// - /// // The boolean `false` is not null. - /// assert_eq!(v["b"].as_null(), None); - /// ``` - pub fn as_null(&self) -> Option<()> { - match *self { - Value::Null => Some(()), - _ => None, - } - } - - /// Looks up a value by a JSON Pointer. - /// - /// JSON Pointer defines a string syntax for identifying a specific value - /// within a JavaScript Object Notation (JSON) document. - /// - /// A Pointer is a Unicode string with the reference tokens separated by `/`. - /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The - /// addressed value is returned and if there is no such value `None` is - /// returned. - /// - /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901). - /// - /// # Examples - /// - /// ``` - /// # use serde_json::json; - /// # - /// let data = json!({ - /// "x": { - /// "y": ["z", "zz"] - /// } - /// }); - /// - /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz")); - /// assert_eq!(data.pointer("/a/b/c"), None); - /// ``` - pub fn pointer(&self, pointer: &str) -> Option<&Value> { - if pointer.is_empty() { - return Some(self); - } - if !pointer.starts_with('/') { - return None; - } - pointer - .split('/') - .skip(1) - .map(|x| x.replace("~1", "/").replace("~0", "~")) - .try_fold(self, |target, token| match target { - Value::Object(map) => map.get(&token), - Value::Array(list) => parse_index(&token).and_then(|x| list.get(x)), - _ => None, - }) - } - - /// Looks up a value by a JSON Pointer and returns a mutable reference to - /// that value. - /// - /// JSON Pointer defines a string syntax for identifying a specific value - /// within a JavaScript Object Notation (JSON) document. - /// - /// A Pointer is a Unicode string with the reference tokens separated by `/`. - /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The - /// addressed value is returned and if there is no such value `None` is - /// returned. - /// - /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901). - /// - /// # Example of Use - /// - /// ``` - /// use serde_json::Value; - /// - /// fn main() { - /// let s = r#"{"x": 1.0, "y": 2.0}"#; - /// let mut value: Value = serde_json::from_str(s).unwrap(); - /// - /// // Check value using read-only pointer - /// assert_eq!(value.pointer("/x"), Some(&1.0.into())); - /// // Change value with direct assignment - /// *value.pointer_mut("/x").unwrap() = 1.5.into(); - /// // Check that new value was written - /// assert_eq!(value.pointer("/x"), Some(&1.5.into())); - /// // Or change the value only if it exists - /// value.pointer_mut("/x").map(|v| *v = 1.5.into()); - /// - /// // "Steal" ownership of a value. Can replace with any valid Value. - /// let old_x = value.pointer_mut("/x").map(Value::take).unwrap(); - /// assert_eq!(old_x, 1.5); - /// assert_eq!(value.pointer("/x").unwrap(), &Value::Null); - /// } - /// ``` - pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value> { - if pointer.is_empty() { - return Some(self); - } - if !pointer.starts_with('/') { - return None; - } - pointer - .split('/') - .skip(1) - .map(|x| x.replace("~1", "/").replace("~0", "~")) - .try_fold(self, |target, token| match target { - Value::Object(map) => map.get_mut(&token), - Value::Array(list) => parse_index(&token).and_then(move |x| list.get_mut(x)), - _ => None, - }) - } - - /// Takes the value out of the `Value`, leaving a `Null` in its place. - /// - /// ``` - /// # use serde_json::json; - /// # - /// let mut v = json!({ "x": "y" }); - /// assert_eq!(v["x"].take(), json!("y")); - /// assert_eq!(v, json!({ "x": null })); - /// ``` - pub fn take(&mut self) -> Value { - mem::replace(self, Value::Null) - } -} - -/// The default value is `Value::Null`. -/// -/// This is useful for handling omitted `Value` fields when deserializing. -/// -/// # Examples -/// -/// ``` -/// # use serde::Deserialize; -/// use serde_json::Value; -/// -/// #[derive(Deserialize)] -/// struct Settings { -/// level: i32, -/// #[serde(default)] -/// extras: Value, -/// } -/// -/// # fn try_main() -> Result<(), serde_json::Error> { -/// let data = r#" { "level": 42 } "#; -/// let s: Settings = serde_json::from_str(data)?; -/// -/// assert_eq!(s.level, 42); -/// assert_eq!(s.extras, Value::Null); -/// # -/// # Ok(()) -/// # } -/// # -/// # try_main().unwrap() -/// ``` -impl Default for Value { - fn default() -> Value { - Value::Null - } -} - -mod de; -mod from; -mod index; -mod partial_eq; -mod ser; - -/// Convert a `T` into `serde_json::Value` which is an enum that can represent -/// any valid JSON data. -/// -/// # Example -/// -/// ``` -/// use serde::Serialize; -/// use serde_json::json; -/// use std::error::Error; -/// -/// #[derive(Serialize)] -/// struct User { -/// fingerprint: String, -/// location: String, -/// } -/// -/// fn compare_json_values() -> Result<(), Box<dyn Error>> { -/// let u = User { -/// fingerprint: "0xF9BA143B95FF6D82".to_owned(), -/// location: "Menlo Park, CA".to_owned(), -/// }; -/// -/// // The type of `expected` is `serde_json::Value` -/// let expected = json!({ -/// "fingerprint": "0xF9BA143B95FF6D82", -/// "location": "Menlo Park, CA", -/// }); -/// -/// let v = serde_json::to_value(u).unwrap(); -/// assert_eq!(v, expected); -/// -/// Ok(()) -/// } -/// # -/// # compare_json_values().unwrap(); -/// ``` -/// -/// # Errors -/// -/// This conversion can fail if `T`'s implementation of `Serialize` decides to -/// fail, or if `T` contains a map with non-string keys. -/// -/// ``` -/// use std::collections::BTreeMap; -/// -/// fn main() { -/// // The keys in this map are vectors, not strings. -/// let mut map = BTreeMap::new(); -/// map.insert(vec![32, 64], "x86"); -/// -/// println!("{}", serde_json::to_value(map).unwrap_err()); -/// } -/// ``` -// Taking by value is more friendly to iterator adapters, option and result -// consumers, etc. See https://github.com/serde-rs/json/pull/149. -pub fn to_value<T>(value: T) -> Result<Value, Error> -where - T: Serialize, -{ - value.serialize(Serializer) -} - -/// Interpret a `serde_json::Value` as an instance of type `T`. -/// -/// # Example -/// -/// ``` -/// use serde::Deserialize; -/// use serde_json::json; -/// -/// #[derive(Deserialize, Debug)] -/// struct User { -/// fingerprint: String, -/// location: String, -/// } -/// -/// fn main() { -/// // The type of `j` is `serde_json::Value` -/// let j = json!({ -/// "fingerprint": "0xF9BA143B95FF6D82", -/// "location": "Menlo Park, CA" -/// }); -/// -/// let u: User = serde_json::from_value(j).unwrap(); -/// println!("{:#?}", u); -/// } -/// ``` -/// -/// # Errors -/// -/// This conversion can fail if the structure of the Value does not match the -/// structure expected by `T`, for example if `T` is a struct type but the Value -/// contains something other than a JSON map. It can also fail if the structure -/// is correct but `T`'s implementation of `Deserialize` decides that something -/// is wrong with the data, for example required struct fields are missing from -/// the JSON map or some number is too big to fit in the expected primitive -/// type. -pub fn from_value<T>(value: Value) -> Result<T, Error> -where - T: DeserializeOwned, -{ - T::deserialize(value) -} diff --git a/vendor/serde_json/src/value/partial_eq.rs b/vendor/serde_json/src/value/partial_eq.rs deleted file mode 100644 index 46c1dbc..0000000 --- a/vendor/serde_json/src/value/partial_eq.rs +++ /dev/null @@ -1,103 +0,0 @@ -use super::Value; -use alloc::string::String; - -fn eq_i64(value: &Value, other: i64) -> bool { - value.as_i64().map_or(false, |i| i == other) -} - -fn eq_u64(value: &Value, other: u64) -> bool { - value.as_u64().map_or(false, |i| i == other) -} - -fn eq_f32(value: &Value, other: f32) -> bool { - match value { - Value::Number(n) => n.as_f32().map_or(false, |i| i == other), - _ => false, - } -} - -fn eq_f64(value: &Value, other: f64) -> bool { - value.as_f64().map_or(false, |i| i == other) -} - -fn eq_bool(value: &Value, other: bool) -> bool { - value.as_bool().map_or(false, |i| i == other) -} - -fn eq_str(value: &Value, other: &str) -> bool { - value.as_str().map_or(false, |i| i == other) -} - -impl PartialEq<str> for Value { - fn eq(&self, other: &str) -> bool { - eq_str(self, other) - } -} - -impl PartialEq<&str> for Value { - fn eq(&self, other: &&str) -> bool { - eq_str(self, *other) - } -} - -impl PartialEq<Value> for str { - fn eq(&self, other: &Value) -> bool { - eq_str(other, self) - } -} - -impl PartialEq<Value> for &str { - fn eq(&self, other: &Value) -> bool { - eq_str(other, *self) - } -} - -impl PartialEq<String> for Value { - fn eq(&self, other: &String) -> bool { - eq_str(self, other.as_str()) - } -} - -impl PartialEq<Value> for String { - fn eq(&self, other: &Value) -> bool { - eq_str(other, self.as_str()) - } -} - -macro_rules! partialeq_numeric { - ($($eq:ident [$($ty:ty)*])*) => { - $($( - impl PartialEq<$ty> for Value { - fn eq(&self, other: &$ty) -> bool { - $eq(self, *other as _) - } - } - - impl PartialEq<Value> for $ty { - fn eq(&self, other: &Value) -> bool { - $eq(other, *self as _) - } - } - - impl<'a> PartialEq<$ty> for &'a Value { - fn eq(&self, other: &$ty) -> bool { - $eq(*self, *other as _) - } - } - - impl<'a> PartialEq<$ty> for &'a mut Value { - fn eq(&self, other: &$ty) -> bool { - $eq(*self, *other as _) - } - } - )*)* - } -} - -partialeq_numeric! { - eq_i64[i8 i16 i32 i64 isize] - eq_u64[u8 u16 u32 u64 usize] - eq_f32[f32] - eq_f64[f64] - eq_bool[bool] -} diff --git a/vendor/serde_json/src/value/ser.rs b/vendor/serde_json/src/value/ser.rs deleted file mode 100644 index 835fa90..0000000 --- a/vendor/serde_json/src/value/ser.rs +++ /dev/null @@ -1,1053 +0,0 @@ -use crate::error::{Error, ErrorCode, Result}; -use crate::map::Map; -use crate::value::{to_value, Value}; -use alloc::borrow::ToOwned; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::fmt::Display; -use core::result; -use serde::ser::{Impossible, Serialize}; - -impl Serialize for Value { - #[inline] - fn serialize<S>(&self, serializer: S) -> result::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::Array(v) => v.serialize(serializer), - #[cfg(any(feature = "std", feature = "alloc"))] - Value::Object(m) => { - use serde::ser::SerializeMap; - let mut map = tri!(serializer.serialize_map(Some(m.len()))); - for (k, v) in m { - tri!(map.serialize_entry(k, v)); - } - map.end() - } - } - } -} - -/// Serializer whose output is a `Value`. -/// -/// This is the serializer that backs [`serde_json::to_value`][crate::to_value]. -/// Unlike the main serde_json serializer which goes from some serializable -/// value of type `T` to JSON text, this one goes from `T` to -/// `serde_json::Value`. -/// -/// The `to_value` function is implementable as: -/// -/// ``` -/// use serde::Serialize; -/// use serde_json::{Error, Value}; -/// -/// pub fn to_value<T>(input: T) -> Result<Value, Error> -/// where -/// T: Serialize, -/// { -/// input.serialize(serde_json::value::Serializer) -/// } -/// ``` -pub struct Serializer; - -impl serde::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> { - Ok(Value::Bool(value)) - } - - #[inline] - fn serialize_i8(self, value: i8) -> Result<Value> { - self.serialize_i64(value as i64) - } - - #[inline] - fn serialize_i16(self, value: i16) -> Result<Value> { - self.serialize_i64(value as i64) - } - - #[inline] - fn serialize_i32(self, value: i32) -> Result<Value> { - self.serialize_i64(value as i64) - } - - fn serialize_i64(self, value: i64) -> Result<Value> { - Ok(Value::Number(value.into())) - } - - fn serialize_i128(self, value: i128) -> Result<Value> { - #[cfg(feature = "arbitrary_precision")] - { - Ok(Value::Number(value.into())) - } - - #[cfg(not(feature = "arbitrary_precision"))] - { - if let Ok(value) = u64::try_from(value) { - Ok(Value::Number(value.into())) - } else if let Ok(value) = i64::try_from(value) { - Ok(Value::Number(value.into())) - } else { - Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0)) - } - } - } - - #[inline] - fn serialize_u8(self, value: u8) -> Result<Value> { - self.serialize_u64(value as u64) - } - - #[inline] - fn serialize_u16(self, value: u16) -> Result<Value> { - self.serialize_u64(value as u64) - } - - #[inline] - fn serialize_u32(self, value: u32) -> Result<Value> { - self.serialize_u64(value as u64) - } - - #[inline] - fn serialize_u64(self, value: u64) -> Result<Value> { - Ok(Value::Number(value.into())) - } - - fn serialize_u128(self, value: u128) -> Result<Value> { - #[cfg(feature = "arbitrary_precision")] - { - Ok(Value::Number(value.into())) - } - - #[cfg(not(feature = "arbitrary_precision"))] - { - if let Ok(value) = u64::try_from(value) { - Ok(Value::Number(value.into())) - } else { - Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0)) - } - } - } - - #[inline] - fn serialize_f32(self, float: f32) -> Result<Value> { - Ok(Value::from(float)) - } - - #[inline] - fn serialize_f64(self, float: f64) -> Result<Value> { - Ok(Value::from(float)) - } - - #[inline] - fn serialize_char(self, value: char) -> Result<Value> { - let mut s = String::new(); - s.push(value); - Ok(Value::String(s)) - } - - #[inline] - 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(b.into())).collect(); - Ok(Value::Array(vec)) - } - - #[inline] - fn serialize_unit(self) -> Result<Value> { - Ok(Value::Null) - } - - #[inline] - fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> { - self.serialize_unit() - } - - #[inline] - fn serialize_unit_variant( - self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - ) -> Result<Value> { - self.serialize_str(variant) - } - - #[inline] - fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value> - where - T: ?Sized + Serialize, - { - value.serialize(self) - } - - fn serialize_newtype_variant<T>( - self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - value: &T, - ) -> Result<Value> - where - T: ?Sized + Serialize, - { - let mut values = Map::new(); - values.insert(String::from(variant), tri!(to_value(value))); - Ok(Value::Object(values)) - } - - #[inline] - fn serialize_none(self) -> Result<Value> { - self.serialize_unit() - } - - #[inline] - fn serialize_some<T>(self, value: &T) -> Result<Value> - where - T: ?Sized + Serialize, - { - value.serialize(self) - } - - fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> { - Ok(SerializeVec { - vec: Vec::with_capacity(len.unwrap_or(0)), - }) - } - - fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> { - self.serialize_seq(Some(len)) - } - - fn serialize_tuple_struct( - self, - _name: &'static str, - len: usize, - ) -> Result<Self::SerializeTupleStruct> { - self.serialize_seq(Some(len)) - } - - fn serialize_tuple_variant( - self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - len: usize, - ) -> Result<Self::SerializeTupleVariant> { - Ok(SerializeTupleVariant { - name: String::from(variant), - vec: Vec::with_capacity(len), - }) - } - - fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { - Ok(SerializeMap::Map { - map: Map::new(), - next_key: None, - }) - } - - fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> { - match name { - #[cfg(feature = "arbitrary_precision")] - crate::number::TOKEN => Ok(SerializeMap::Number { out_value: None }), - #[cfg(feature = "raw_value")] - crate::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }), - _ => self.serialize_map(Some(len)), - } - } - - fn serialize_struct_variant( - self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeStructVariant> { - Ok(SerializeStructVariant { - name: String::from(variant), - map: Map::new(), - }) - } - - fn collect_str<T>(self, value: &T) -> Result<Value> - where - T: ?Sized + Display, - { - Ok(Value::String(value.to_string())) - } -} - -pub struct SerializeVec { - vec: Vec<Value>, -} - -pub struct SerializeTupleVariant { - name: String, - vec: Vec<Value>, -} - -pub enum SerializeMap { - Map { - map: Map<String, Value>, - next_key: Option<String>, - }, - #[cfg(feature = "arbitrary_precision")] - Number { out_value: Option<Value> }, - #[cfg(feature = "raw_value")] - RawValue { out_value: Option<Value> }, -} - -pub struct SerializeStructVariant { - name: String, - map: Map<String, Value>, -} - -impl serde::ser::SerializeSeq for SerializeVec { - type Ok = Value; - type Error = Error; - - fn serialize_element<T>(&mut self, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - self.vec.push(tri!(to_value(value))); - Ok(()) - } - - fn end(self) -> Result<Value> { - Ok(Value::Array(self.vec)) - } -} - -impl serde::ser::SerializeTuple for SerializeVec { - type Ok = Value; - type Error = Error; - - fn serialize_element<T>(&mut self, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - serde::ser::SerializeSeq::serialize_element(self, value) - } - - fn end(self) -> Result<Value> { - serde::ser::SerializeSeq::end(self) - } -} - -impl serde::ser::SerializeTupleStruct for SerializeVec { - type Ok = Value; - type Error = Error; - - fn serialize_field<T>(&mut self, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - serde::ser::SerializeSeq::serialize_element(self, value) - } - - fn end(self) -> Result<Value> { - serde::ser::SerializeSeq::end(self) - } -} - -impl serde::ser::SerializeTupleVariant for SerializeTupleVariant { - type Ok = Value; - type Error = Error; - - fn serialize_field<T>(&mut self, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - self.vec.push(tri!(to_value(value))); - Ok(()) - } - - fn end(self) -> Result<Value> { - let mut object = Map::new(); - - object.insert(self.name, Value::Array(self.vec)); - - Ok(Value::Object(object)) - } -} - -impl serde::ser::SerializeMap for SerializeMap { - type Ok = Value; - type Error = Error; - - fn serialize_key<T>(&mut self, key: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - match self { - SerializeMap::Map { next_key, .. } => { - *next_key = Some(tri!(key.serialize(MapKeySerializer))); - Ok(()) - } - #[cfg(feature = "arbitrary_precision")] - SerializeMap::Number { .. } => unreachable!(), - #[cfg(feature = "raw_value")] - SerializeMap::RawValue { .. } => unreachable!(), - } - } - - fn serialize_value<T>(&mut self, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - match self { - SerializeMap::Map { map, next_key } => { - let key = next_key.take(); - // Panic because this indicates a bug in the program rather than an - // expected failure. - let key = key.expect("serialize_value called before serialize_key"); - map.insert(key, tri!(to_value(value))); - Ok(()) - } - #[cfg(feature = "arbitrary_precision")] - SerializeMap::Number { .. } => unreachable!(), - #[cfg(feature = "raw_value")] - SerializeMap::RawValue { .. } => unreachable!(), - } - } - - fn end(self) -> Result<Value> { - match self { - SerializeMap::Map { map, .. } => Ok(Value::Object(map)), - #[cfg(feature = "arbitrary_precision")] - SerializeMap::Number { .. } => unreachable!(), - #[cfg(feature = "raw_value")] - SerializeMap::RawValue { .. } => unreachable!(), - } - } -} - -struct MapKeySerializer; - -fn key_must_be_a_string() -> Error { - Error::syntax(ErrorCode::KeyMustBeAString, 0, 0) -} - -fn float_key_must_be_finite() -> Error { - Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0) -} - -impl serde::Serializer for MapKeySerializer { - type Ok = String; - type Error = Error; - - type SerializeSeq = Impossible<String, Error>; - type SerializeTuple = Impossible<String, Error>; - type SerializeTupleStruct = Impossible<String, Error>; - type SerializeTupleVariant = Impossible<String, Error>; - type SerializeMap = Impossible<String, Error>; - type SerializeStruct = Impossible<String, Error>; - type SerializeStructVariant = Impossible<String, Error>; - - #[inline] - fn serialize_unit_variant( - self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - ) -> Result<String> { - Ok(variant.to_owned()) - } - - #[inline] - fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<String> - where - T: ?Sized + Serialize, - { - value.serialize(self) - } - - fn serialize_bool(self, value: bool) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_i8(self, value: i8) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_i16(self, value: i16) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_i32(self, value: i32) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_i64(self, value: i64) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_u8(self, value: u8) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_u16(self, value: u16) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_u32(self, value: u32) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_u64(self, value: u64) -> Result<String> { - Ok(value.to_string()) - } - - fn serialize_f32(self, value: f32) -> Result<String> { - if value.is_finite() { - Ok(ryu::Buffer::new().format_finite(value).to_owned()) - } else { - Err(float_key_must_be_finite()) - } - } - - fn serialize_f64(self, value: f64) -> Result<String> { - if value.is_finite() { - Ok(ryu::Buffer::new().format_finite(value).to_owned()) - } else { - Err(float_key_must_be_finite()) - } - } - - #[inline] - fn serialize_char(self, value: char) -> Result<String> { - Ok({ - let mut s = String::new(); - s.push(value); - s - }) - } - - #[inline] - fn serialize_str(self, value: &str) -> Result<String> { - Ok(value.to_owned()) - } - - fn serialize_bytes(self, _value: &[u8]) -> Result<String> { - Err(key_must_be_a_string()) - } - - fn serialize_unit(self) -> Result<String> { - Err(key_must_be_a_string()) - } - - fn serialize_unit_struct(self, _name: &'static str) -> Result<String> { - Err(key_must_be_a_string()) - } - - fn serialize_newtype_variant<T>( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T, - ) -> Result<String> - where - T: ?Sized + Serialize, - { - Err(key_must_be_a_string()) - } - - fn serialize_none(self) -> Result<String> { - Err(key_must_be_a_string()) - } - - fn serialize_some<T>(self, _value: &T) -> Result<String> - where - T: ?Sized + Serialize, - { - Err(key_must_be_a_string()) - } - - fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> { - Err(key_must_be_a_string()) - } - - fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> { - Err(key_must_be_a_string()) - } - - fn serialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - ) -> Result<Self::SerializeTupleStruct> { - Err(key_must_be_a_string()) - } - - fn serialize_tuple_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeTupleVariant> { - Err(key_must_be_a_string()) - } - - fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { - Err(key_must_be_a_string()) - } - - fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> { - Err(key_must_be_a_string()) - } - - fn serialize_struct_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeStructVariant> { - Err(key_must_be_a_string()) - } - - fn collect_str<T>(self, value: &T) -> Result<String> - where - T: ?Sized + Display, - { - Ok(value.to_string()) - } -} - -impl serde::ser::SerializeStruct for SerializeMap { - type Ok = Value; - type Error = Error; - - fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - match self { - SerializeMap::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value), - #[cfg(feature = "arbitrary_precision")] - SerializeMap::Number { out_value } => { - if key == crate::number::TOKEN { - *out_value = Some(tri!(value.serialize(NumberValueEmitter))); - Ok(()) - } else { - Err(invalid_number()) - } - } - #[cfg(feature = "raw_value")] - SerializeMap::RawValue { out_value } => { - if key == crate::raw::TOKEN { - *out_value = Some(tri!(value.serialize(RawValueEmitter))); - Ok(()) - } else { - Err(invalid_raw_value()) - } - } - } - } - - fn end(self) -> Result<Value> { - match self { - SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self), - #[cfg(feature = "arbitrary_precision")] - SerializeMap::Number { out_value, .. } => { - Ok(out_value.expect("number value was not emitted")) - } - #[cfg(feature = "raw_value")] - SerializeMap::RawValue { out_value, .. } => { - Ok(out_value.expect("raw value was not emitted")) - } - } - } -} - -impl serde::ser::SerializeStructVariant for SerializeStructVariant { - type Ok = Value; - type Error = Error; - - fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> - where - T: ?Sized + Serialize, - { - self.map.insert(String::from(key), tri!(to_value(value))); - Ok(()) - } - - fn end(self) -> Result<Value> { - let mut object = Map::new(); - - object.insert(self.name, Value::Object(self.map)); - - Ok(Value::Object(object)) - } -} - -#[cfg(feature = "arbitrary_precision")] -struct NumberValueEmitter; - -#[cfg(feature = "arbitrary_precision")] -fn invalid_number() -> Error { - Error::syntax(ErrorCode::InvalidNumber, 0, 0) -} - -#[cfg(feature = "arbitrary_precision")] -impl serde::ser::Serializer for NumberValueEmitter { - type Ok = Value; - type Error = Error; - - type SerializeSeq = Impossible<Value, Error>; - type SerializeTuple = Impossible<Value, Error>; - type SerializeTupleStruct = Impossible<Value, Error>; - type SerializeTupleVariant = Impossible<Value, Error>; - type SerializeMap = Impossible<Value, Error>; - type SerializeStruct = Impossible<Value, Error>; - type SerializeStructVariant = Impossible<Value, Error>; - - fn serialize_bool(self, _v: bool) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_i8(self, _v: i8) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_i16(self, _v: i16) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_i32(self, _v: i32) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_i64(self, _v: i64) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_u8(self, _v: u8) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_u16(self, _v: u16) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_u32(self, _v: u32) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_u64(self, _v: u64) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_f32(self, _v: f32) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_f64(self, _v: f64) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_char(self, _v: char) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_str(self, value: &str) -> Result<Value> { - let n = tri!(value.to_owned().parse()); - Ok(Value::Number(n)) - } - - fn serialize_bytes(self, _value: &[u8]) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_none(self) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_some<T>(self, _value: &T) -> Result<Value> - where - T: ?Sized + Serialize, - { - Err(invalid_number()) - } - - fn serialize_unit(self) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_unit_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - ) -> Result<Value> { - Err(invalid_number()) - } - - fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value> - where - T: ?Sized + Serialize, - { - Err(invalid_number()) - } - - fn serialize_newtype_variant<T>( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T, - ) -> Result<Value> - where - T: ?Sized + Serialize, - { - Err(invalid_number()) - } - - fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> { - Err(invalid_number()) - } - - fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> { - Err(invalid_number()) - } - - fn serialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - ) -> Result<Self::SerializeTupleStruct> { - Err(invalid_number()) - } - - fn serialize_tuple_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeTupleVariant> { - Err(invalid_number()) - } - - fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { - Err(invalid_number()) - } - - fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> { - Err(invalid_number()) - } - - fn serialize_struct_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeStructVariant> { - Err(invalid_number()) - } -} - -#[cfg(feature = "raw_value")] -struct RawValueEmitter; - -#[cfg(feature = "raw_value")] -fn invalid_raw_value() -> Error { - Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0) -} - -#[cfg(feature = "raw_value")] -impl serde::ser::Serializer for RawValueEmitter { - type Ok = Value; - type Error = Error; - - type SerializeSeq = Impossible<Value, Error>; - type SerializeTuple = Impossible<Value, Error>; - type SerializeTupleStruct = Impossible<Value, Error>; - type SerializeTupleVariant = Impossible<Value, Error>; - type SerializeMap = Impossible<Value, Error>; - type SerializeStruct = Impossible<Value, Error>; - type SerializeStructVariant = Impossible<Value, Error>; - - fn serialize_bool(self, _v: bool) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_i8(self, _v: i8) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_i16(self, _v: i16) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_i32(self, _v: i32) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_i64(self, _v: i64) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_u8(self, _v: u8) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_u16(self, _v: u16) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_u32(self, _v: u32) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_u64(self, _v: u64) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_f32(self, _v: f32) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_f64(self, _v: f64) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_char(self, _v: char) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_str(self, value: &str) -> Result<Value> { - crate::from_str(value) - } - - fn serialize_bytes(self, _value: &[u8]) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_none(self) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_some<T>(self, _value: &T) -> Result<Value> - where - T: ?Sized + Serialize, - { - Err(invalid_raw_value()) - } - - fn serialize_unit(self) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_unit_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - ) -> Result<Value> { - Err(invalid_raw_value()) - } - - fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value> - where - T: ?Sized + Serialize, - { - Err(invalid_raw_value()) - } - - fn serialize_newtype_variant<T>( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T, - ) -> Result<Value> - where - T: ?Sized + Serialize, - { - Err(invalid_raw_value()) - } - - fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> { - Err(invalid_raw_value()) - } - - fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> { - Err(invalid_raw_value()) - } - - fn serialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - ) -> Result<Self::SerializeTupleStruct> { - Err(invalid_raw_value()) - } - - fn serialize_tuple_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeTupleVariant> { - Err(invalid_raw_value()) - } - - fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { - Err(invalid_raw_value()) - } - - fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> { - Err(invalid_raw_value()) - } - - fn serialize_struct_variant( - self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize, - ) -> Result<Self::SerializeStructVariant> { - Err(invalid_raw_value()) - } - - fn collect_str<T>(self, value: &T) -> Result<Self::Ok> - where - T: ?Sized + Display, - { - self.serialize_str(&value.to_string()) - } -} |