summaryrefslogtreecommitdiffstats
path: root/vendor/serde_json/src/value
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/serde_json/src/value')
-rw-r--r--vendor/serde_json/src/value/de.rs1386
-rw-r--r--vendor/serde_json/src/value/from.rs282
-rw-r--r--vendor/serde_json/src/value/index.rs258
-rw-r--r--vendor/serde_json/src/value/mod.rs989
-rw-r--r--vendor/serde_json/src/value/partial_eq.rs95
-rw-r--r--vendor/serde_json/src/value/ser.rs1025
6 files changed, 4035 insertions, 0 deletions
diff --git a/vendor/serde_json/src/value/de.rs b/vendor/serde_json/src/value/de.rs
new file mode 100644
index 000000000..cc1d38565
--- /dev/null
+++ b/vendor/serde_json/src/value/de.rs
@@ -0,0 +1,1386 @@
+use crate::error::Error;
+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, serde_if_integer128};
+
+#[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 visitor.next_key_seed(KeyClassifier)? {
+ #[cfg(feature = "arbitrary_precision")]
+ Some(KeyClass::Number) => {
+ let number: NumberFromString = visitor.next_value()?;
+ Ok(Value::Number(number.value))
+ }
+ #[cfg(feature = "raw_value")]
+ Some(KeyClass::RawValue) => {
+ let value = 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_u8);
+ deserialize_number!(deserialize_u16);
+ deserialize_number!(deserialize_u32);
+ deserialize_number!(deserialize_u64);
+ deserialize_number!(deserialize_f32);
+ deserialize_number!(deserialize_f64);
+
+ serde_if_integer128! {
+ deserialize_number!(deserialize_i128);
+ deserialize_number!(deserialize_u128);
+ }
+
+ #[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
+ }
+}
+
+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_value_ref_number!(deserialize_u8);
+ deserialize_value_ref_number!(deserialize_u16);
+ deserialize_value_ref_number!(deserialize_u32);
+ deserialize_value_ref_number!(deserialize_u64);
+ deserialize_value_ref_number!(deserialize_f32);
+ deserialize_value_ref_number!(deserialize_f64);
+
+ serde_if_integer128! {
+ deserialize_number!(deserialize_i128);
+ deserialize_number!(deserialize_u128);
+ }
+
+ 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(ref 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(ref 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_integer_key {
+ ($method:ident => $visit:ident) => {
+ fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match (self.key.parse(), self.key) {
+ (Ok(integer), _) => visitor.$visit(integer),
+ (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
+ #[cfg(any(feature = "std", feature = "alloc"))]
+ (Err(_), Cow::Owned(s)) => visitor.visit_string(s),
+ }
+ }
+ };
+}
+
+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_integer_key!(deserialize_i8 => visit_i8);
+ deserialize_integer_key!(deserialize_i16 => visit_i16);
+ deserialize_integer_key!(deserialize_i32 => visit_i32);
+ deserialize_integer_key!(deserialize_i64 => visit_i64);
+ deserialize_integer_key!(deserialize_u8 => visit_u8);
+ deserialize_integer_key!(deserialize_u16 => visit_u16);
+ deserialize_integer_key!(deserialize_u32 => visit_u32);
+ deserialize_integer_key!(deserialize_u64 => visit_u64);
+
+ serde_if_integer128! {
+ deserialize_integer_key!(deserialize_i128 => visit_i128);
+ deserialize_integer_key!(deserialize_u128 => visit_u128);
+ }
+
+ #[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! {
+ bool f32 f64 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 = 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
new file mode 100644
index 000000000..858a6e48a
--- /dev/null
+++ b/vendor/serde_json/src/value/from.rs
@@ -0,0 +1,282 @@
+use super::Value;
+use crate::map::Map;
+use crate::number::Number;
+use alloc::borrow::Cow;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::iter::FromIterator;
+
+#[cfg(feature = "arbitrary_precision")]
+use serde::serde_if_integer128;
+
+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")]
+serde_if_integer128! {
+ from_integer! {
+ i128 u128
+ }
+}
+
+impl From<f32> for Value {
+ /// Convert 32-bit floating point number to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use serde_json::Value;
+ ///
+ /// let f: f32 = 13.37;
+ /// let x: Value = f.into();
+ /// ```
+ fn from(f: f32) -> Self {
+ From::from(f as f64)
+ }
+}
+
+impl From<f64> for Value {
+ /// Convert 64-bit floating point number to `Value`
+ ///
+ /// # 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`
+ ///
+ /// # 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`
+ ///
+ /// # 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<'a> From<&'a str> for Value {
+ /// Convert string slice to `Value`
+ ///
+ /// # 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`
+ ///
+ /// # 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`
+ ///
+ /// # 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`
+ ///
+ /// # 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`
+ ///
+ /// # 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<'a, T: Clone + Into<Value>> From<&'a [T]> for Value {
+ /// Convert a slice to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use serde_json::Value;
+ ///
+ /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
+ /// let x: Value = v.into();
+ /// ```
+ fn from(f: &'a [T]) -> Self {
+ Value::Array(f.iter().cloned().map(Into::into).collect())
+ }
+}
+
+impl<T: Into<Value>> FromIterator<T> for Value {
+ /// Convert an iteratable type to a `Value`
+ ///
+ /// # 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 {
+ /// Convert an iteratable type to a `Value`
+ ///
+ /// # 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`
+ ///
+ /// # 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
new file mode 100644
index 000000000..c74042b75
--- /dev/null
+++ b/vendor/serde_json/src/value/index.rs
@@ -0,0 +1,258 @@
+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<'a, T> Index for &'a 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
new file mode 100644
index 000000000..4793e93ec
--- /dev/null
+++ b/vendor/serde_json/src/value/mod.rs
@@ -0,0 +1,989 @@
+//! 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]: https://docs.serde.rs/serde_json/macro.json.html
+//! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
+//! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
+//! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
+
+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")]
+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.debug_tuple("Null").finish(),
+ Value::Bool(v) => formatter.debug_tuple("Bool").field(v).finish(),
+ Value::Number(v) => Debug::fmt(v, formatter),
+ Value::String(v) => formatter.debug_tuple("String").field(v).finish(),
+ Value::Array(v) => {
+ formatter.write_str("Array(")?;
+ Debug::fmt(v, formatter)?;
+ formatter.write_str(")")
+ }
+ Value::Object(v) => {
+ formatter.write_str("Object(")?;
+ Debug::fmt(v, formatter)?;
+ formatter.write_str(")")
+ }
+ }
+ }
+}
+
+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,
+ }
+ }
+
+ /// 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<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
new file mode 100644
index 000000000..b4ef84c4f
--- /dev/null
+++ b/vendor/serde_json/src/value/partial_eq.rs
@@ -0,0 +1,95 @@
+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_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<'a> PartialEq<&'a 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<'a> PartialEq<Value> for &'a 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_f64[f32 f64]
+ eq_bool[bool]
+}
diff --git a/vendor/serde_json/src/value/ser.rs b/vendor/serde_json/src/value/ser.rs
new file mode 100644
index 000000000..c142dacbf
--- /dev/null
+++ b/vendor/serde_json/src/value/ser.rs
@@ -0,0 +1,1025 @@
+use crate::error::{Error, ErrorCode, Result};
+use crate::map::Map;
+use crate::number::Number;
+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};
+
+#[cfg(feature = "arbitrary_precision")]
+use serde::serde_if_integer128;
+
+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()))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ serde_if_integer128! {
+ fn serialize_i128(self, value: i128) -> Result<Value> {
+ Ok(Value::Number(value.into()))
+ }
+ }
+
+ #[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()))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ serde_if_integer128! {
+ fn serialize_u128(self, value: u128) -> Result<Value> {
+ Ok(Value::Number(value.into()))
+ }
+ }
+
+ #[inline]
+ fn serialize_f32(self, value: f32) -> Result<Value> {
+ self.serialize_f64(value as f64)
+ }
+
+ #[inline]
+ fn serialize_f64(self, value: f64) -> Result<Value> {
+ Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
+ }
+
+ #[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)
+}
+
+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> {
+ Err(key_must_be_a_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> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_f64(self, _value: f64) -> Result<String> {
+ Err(key_must_be_a_string())
+ }
+
+ #[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(value.serialize(NumberValueEmitter)?);
+ Ok(())
+ } else {
+ Err(invalid_number())
+ }
+ }
+ #[cfg(feature = "raw_value")]
+ SerializeMap::RawValue { out_value } => {
+ if key == crate::raw::TOKEN {
+ *out_value = Some(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())
+ }
+}