1508 lines
40 KiB
Rust
1508 lines
40 KiB
Rust
use crate::error::{Error, ErrorCode};
|
|
use crate::map::Map;
|
|
use crate::number::Number;
|
|
use crate::value::Value;
|
|
use alloc::borrow::{Cow, ToOwned};
|
|
use alloc::string::String;
|
|
#[cfg(feature = "raw_value")]
|
|
use alloc::string::ToString;
|
|
use alloc::vec::{self, Vec};
|
|
use core::fmt;
|
|
use core::slice;
|
|
use core::str::FromStr;
|
|
use serde::de::{
|
|
self, Deserialize, DeserializeSeed, Deserializer as _, EnumAccess, Expected, IntoDeserializer,
|
|
MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor,
|
|
};
|
|
use serde::forward_to_deserialize_any;
|
|
|
|
#[cfg(feature = "arbitrary_precision")]
|
|
use crate::number::NumberFromString;
|
|
|
|
impl<'de> Deserialize<'de> for Value {
|
|
#[inline]
|
|
fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
struct ValueVisitor;
|
|
|
|
impl<'de> Visitor<'de> for ValueVisitor {
|
|
type Value = Value;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_str("any valid JSON value")
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
|
|
Ok(Value::Bool(value))
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
|
|
Ok(Value::Number(value.into()))
|
|
}
|
|
|
|
fn visit_i128<E>(self, value: i128) -> Result<Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
let de = serde::de::value::I128Deserializer::new(value);
|
|
Number::deserialize(de).map(Value::Number)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
|
|
Ok(Value::Number(value.into()))
|
|
}
|
|
|
|
fn visit_u128<E>(self, value: u128) -> Result<Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
let de = serde::de::value::U128Deserializer::new(value);
|
|
Number::deserialize(de).map(Value::Number)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
|
|
Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
|
|
}
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
|
#[inline]
|
|
fn visit_str<E>(self, value: &str) -> Result<Value, E>
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
self.visit_string(String::from(value))
|
|
}
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
|
#[inline]
|
|
fn visit_string<E>(self, value: String) -> Result<Value, E> {
|
|
Ok(Value::String(value))
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_none<E>(self) -> Result<Value, E> {
|
|
Ok(Value::Null)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
Deserialize::deserialize(deserializer)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_unit<E>(self) -> Result<Value, E> {
|
|
Ok(Value::Null)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
|
|
where
|
|
V: SeqAccess<'de>,
|
|
{
|
|
let mut vec = Vec::new();
|
|
|
|
while let Some(elem) = tri!(visitor.next_element()) {
|
|
vec.push(elem);
|
|
}
|
|
|
|
Ok(Value::Array(vec))
|
|
}
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
|
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
|
|
where
|
|
V: MapAccess<'de>,
|
|
{
|
|
match tri!(visitor.next_key_seed(KeyClassifier)) {
|
|
#[cfg(feature = "arbitrary_precision")]
|
|
Some(KeyClass::Number) => {
|
|
let number: NumberFromString = tri!(visitor.next_value());
|
|
Ok(Value::Number(number.value))
|
|
}
|
|
#[cfg(feature = "raw_value")]
|
|
Some(KeyClass::RawValue) => {
|
|
let value = tri!(visitor.next_value_seed(crate::raw::BoxedFromString));
|
|
crate::from_str(value.get()).map_err(de::Error::custom)
|
|
}
|
|
Some(KeyClass::Map(first_key)) => {
|
|
let mut values = Map::new();
|
|
|
|
values.insert(first_key, tri!(visitor.next_value()));
|
|
while let Some((key, value)) = tri!(visitor.next_entry()) {
|
|
values.insert(key, value);
|
|
}
|
|
|
|
Ok(Value::Object(values))
|
|
}
|
|
None => Ok(Value::Object(Map::new())),
|
|
}
|
|
}
|
|
}
|
|
|
|
deserializer.deserialize_any(ValueVisitor)
|
|
}
|
|
}
|
|
|
|
impl FromStr for Value {
|
|
type Err = Error;
|
|
fn from_str(s: &str) -> Result<Value, Error> {
|
|
crate::from_str(s)
|
|
}
|
|
}
|
|
|
|
impl FromStr for Map<String, Value> {
|
|
type Err = Error;
|
|
fn from_str(s: &str) -> Result<Self, Error> {
|
|
crate::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",
|
|
))
|
|
}
|
|
}
|
|
|
|
impl<'de> serde::Deserializer<'de> for Map<String, Value> {
|
|
type Error = Error;
|
|
|
|
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
let len = self.len();
|
|
let mut deserializer = MapDeserializer::new(self);
|
|
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",
|
|
))
|
|
}
|
|
}
|
|
|
|
fn deserialize_enum<V>(
|
|
self,
|
|
_name: &'static str,
|
|
_variants: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Self::Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
let mut iter = self.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",
|
|
));
|
|
}
|
|
|
|
visitor.visit_enum(EnumDeserializer {
|
|
variant,
|
|
value: Some(value),
|
|
})
|
|
}
|
|
|
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
drop(self);
|
|
visitor.visit_unit()
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
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),
|
|
#[cfg(not(any(feature = "std", feature = "alloc")))]
|
|
Value::String(_) => unreachable!(),
|
|
Value::Array(v) => visit_array(v, visitor),
|
|
Value::Object(v) => v.deserialize_any(visitor),
|
|
}
|
|
}
|
|
|
|
deserialize_number!(deserialize_i8);
|
|
deserialize_number!(deserialize_i16);
|
|
deserialize_number!(deserialize_i32);
|
|
deserialize_number!(deserialize_i64);
|
|
deserialize_number!(deserialize_i128);
|
|
deserialize_number!(deserialize_u8);
|
|
deserialize_number!(deserialize_u16);
|
|
deserialize_number!(deserialize_u32);
|
|
deserialize_number!(deserialize_u64);
|
|
deserialize_number!(deserialize_u128);
|
|
deserialize_number!(deserialize_f32);
|
|
deserialize_number!(deserialize_f64);
|
|
|
|
#[inline]
|
|
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self {
|
|
Value::Null => visitor.visit_none(),
|
|
_ => visitor.visit_some(self),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn deserialize_enum<V>(
|
|
self,
|
|
name: &'static str,
|
|
variants: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self {
|
|
Value::Object(value) => value.deserialize_enum(name, variants, visitor),
|
|
Value::String(variant) => visitor.visit_enum(EnumDeserializer {
|
|
variant,
|
|
value: None,
|
|
}),
|
|
other => Err(serde::de::Error::invalid_type(
|
|
other.unexpected(),
|
|
&"string or map",
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[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) => v.deserialize_any(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) => v.deserialize_any(visitor),
|
|
_ => Err(self.invalid_type(&visitor)),
|
|
}
|
|
}
|
|
|
|
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
self.deserialize_string(visitor)
|
|
}
|
|
|
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
drop(self);
|
|
visitor.visit_unit()
|
|
}
|
|
}
|
|
|
|
struct EnumDeserializer {
|
|
variant: String,
|
|
value: Option<Value>,
|
|
}
|
|
|
|
impl<'de> EnumAccess<'de> for EnumDeserializer {
|
|
type Error = Error;
|
|
type Variant = VariantDeserializer;
|
|
|
|
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
|
|
where
|
|
V: DeserializeSeed<'de>,
|
|
{
|
|
let variant = self.variant.into_deserializer();
|
|
let visitor = VariantDeserializer { value: self.value };
|
|
seed.deserialize(variant).map(|v| (v, visitor))
|
|
}
|
|
}
|
|
|
|
impl<'de> IntoDeserializer<'de, Error> for Value {
|
|
type Deserializer = Self;
|
|
|
|
fn into_deserializer(self) -> Self::Deserializer {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<'de> IntoDeserializer<'de, Error> for &'de Value {
|
|
type Deserializer = Self;
|
|
|
|
fn into_deserializer(self) -> Self::Deserializer {
|
|
self
|
|
}
|
|
}
|
|
|
|
struct VariantDeserializer {
|
|
value: Option<Value>,
|
|
}
|
|
|
|
impl<'de> VariantAccess<'de> for VariantDeserializer {
|
|
type Error = Error;
|
|
|
|
fn unit_variant(self) -> Result<(), Error> {
|
|
match self.value {
|
|
Some(value) => Deserialize::deserialize(value),
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
|
|
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
|
|
where
|
|
T: DeserializeSeed<'de>,
|
|
{
|
|
match self.value {
|
|
Some(value) => seed.deserialize(value),
|
|
None => Err(serde::de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"newtype variant",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self.value {
|
|
Some(Value::Array(v)) => {
|
|
if v.is_empty() {
|
|
visitor.visit_unit()
|
|
} else {
|
|
visit_array(v, visitor)
|
|
}
|
|
}
|
|
Some(other) => Err(serde::de::Error::invalid_type(
|
|
other.unexpected(),
|
|
&"tuple variant",
|
|
)),
|
|
None => Err(serde::de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"tuple variant",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn struct_variant<V>(
|
|
self,
|
|
_fields: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self.value {
|
|
Some(Value::Object(v)) => v.deserialize_any(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",
|
|
))
|
|
}
|
|
}
|
|
|
|
impl<'de> serde::Deserializer<'de> for &'de Map<String, Value> {
|
|
type Error = Error;
|
|
|
|
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
let len = self.len();
|
|
let mut deserializer = MapRefDeserializer::new(self);
|
|
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",
|
|
))
|
|
}
|
|
}
|
|
|
|
fn deserialize_enum<V>(
|
|
self,
|
|
_name: &'static str,
|
|
_variants: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Self::Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
let mut iter = self.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",
|
|
));
|
|
}
|
|
|
|
visitor.visit_enum(EnumRefDeserializer {
|
|
variant,
|
|
value: Some(value),
|
|
})
|
|
}
|
|
|
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
visitor.visit_unit()
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
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) => v.deserialize_any(visitor),
|
|
}
|
|
}
|
|
|
|
deserialize_value_ref_number!(deserialize_i8);
|
|
deserialize_value_ref_number!(deserialize_i16);
|
|
deserialize_value_ref_number!(deserialize_i32);
|
|
deserialize_value_ref_number!(deserialize_i64);
|
|
deserialize_number!(deserialize_i128);
|
|
deserialize_value_ref_number!(deserialize_u8);
|
|
deserialize_value_ref_number!(deserialize_u16);
|
|
deserialize_value_ref_number!(deserialize_u32);
|
|
deserialize_value_ref_number!(deserialize_u64);
|
|
deserialize_number!(deserialize_u128);
|
|
deserialize_value_ref_number!(deserialize_f32);
|
|
deserialize_value_ref_number!(deserialize_f64);
|
|
|
|
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match *self {
|
|
Value::Null => visitor.visit_none(),
|
|
_ => visitor.visit_some(self),
|
|
}
|
|
}
|
|
|
|
fn deserialize_enum<V>(
|
|
self,
|
|
name: &'static str,
|
|
variants: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self {
|
|
Value::Object(value) => value.deserialize_enum(name, variants, visitor),
|
|
Value::String(variant) => visitor.visit_enum(EnumRefDeserializer {
|
|
variant,
|
|
value: None,
|
|
}),
|
|
other => Err(serde::de::Error::invalid_type(
|
|
other.unexpected(),
|
|
&"string or map",
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[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) => v.deserialize_any(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) => v.deserialize_any(visitor),
|
|
_ => Err(self.invalid_type(&visitor)),
|
|
}
|
|
}
|
|
|
|
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
self.deserialize_str(visitor)
|
|
}
|
|
|
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
visitor.visit_unit()
|
|
}
|
|
}
|
|
|
|
struct EnumRefDeserializer<'de> {
|
|
variant: &'de str,
|
|
value: Option<&'de Value>,
|
|
}
|
|
|
|
impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
|
|
type Error = Error;
|
|
type Variant = VariantRefDeserializer<'de>;
|
|
|
|
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
|
|
where
|
|
V: DeserializeSeed<'de>,
|
|
{
|
|
let variant = self.variant.into_deserializer();
|
|
let visitor = VariantRefDeserializer { value: self.value };
|
|
seed.deserialize(variant).map(|v| (v, visitor))
|
|
}
|
|
}
|
|
|
|
struct VariantRefDeserializer<'de> {
|
|
value: Option<&'de Value>,
|
|
}
|
|
|
|
impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
|
|
type Error = Error;
|
|
|
|
fn unit_variant(self) -> Result<(), Error> {
|
|
match self.value {
|
|
Some(value) => Deserialize::deserialize(value),
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
|
|
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
|
|
where
|
|
T: DeserializeSeed<'de>,
|
|
{
|
|
match self.value {
|
|
Some(value) => seed.deserialize(value),
|
|
None => Err(serde::de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"newtype variant",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self.value {
|
|
Some(Value::Array(v)) => {
|
|
if v.is_empty() {
|
|
visitor.visit_unit()
|
|
} else {
|
|
visit_array_ref(v, visitor)
|
|
}
|
|
}
|
|
Some(other) => Err(serde::de::Error::invalid_type(
|
|
other.unexpected(),
|
|
&"tuple variant",
|
|
)),
|
|
None => Err(serde::de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"tuple variant",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn struct_variant<V>(
|
|
self,
|
|
_fields: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
match self.value {
|
|
Some(Value::Object(v)) => v.deserialize_any(visitor),
|
|
Some(other) => Err(serde::de::Error::invalid_type(
|
|
other.unexpected(),
|
|
&"struct variant",
|
|
)),
|
|
None => Err(serde::de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"struct variant",
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
|
|
struct SeqRefDeserializer<'de> {
|
|
iter: slice::Iter<'de, Value>,
|
|
}
|
|
|
|
impl<'de> SeqRefDeserializer<'de> {
|
|
fn new(slice: &'de [Value]) -> Self {
|
|
SeqRefDeserializer { iter: slice.iter() }
|
|
}
|
|
}
|
|
|
|
impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
|
|
type Error = Error;
|
|
|
|
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
|
|
where
|
|
T: DeserializeSeed<'de>,
|
|
{
|
|
match self.iter.next() {
|
|
Some(value) => seed.deserialize(value).map(Some),
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
|
|
fn size_hint(&self) -> Option<usize> {
|
|
match self.iter.size_hint() {
|
|
(lower, Some(upper)) if lower == upper => Some(upper),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct MapRefDeserializer<'de> {
|
|
iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
|
|
value: Option<&'de Value>,
|
|
}
|
|
|
|
impl<'de> MapRefDeserializer<'de> {
|
|
fn new(map: &'de Map<String, Value>) -> Self {
|
|
MapRefDeserializer {
|
|
iter: map.into_iter(),
|
|
value: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
|
|
type Error = Error;
|
|
|
|
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
|
|
where
|
|
T: DeserializeSeed<'de>,
|
|
{
|
|
match self.iter.next() {
|
|
Some((key, value)) => {
|
|
self.value = Some(value);
|
|
let key_de = MapKeyDeserializer {
|
|
key: Cow::Borrowed(&**key),
|
|
};
|
|
seed.deserialize(key_de).map(Some)
|
|
}
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
|
|
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
|
|
where
|
|
T: DeserializeSeed<'de>,
|
|
{
|
|
match self.value.take() {
|
|
Some(value) => seed.deserialize(value),
|
|
None => Err(serde::de::Error::custom("value is missing")),
|
|
}
|
|
}
|
|
|
|
fn size_hint(&self) -> Option<usize> {
|
|
match self.iter.size_hint() {
|
|
(lower, Some(upper)) if lower == upper => Some(upper),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct MapKeyDeserializer<'de> {
|
|
key: Cow<'de, str>,
|
|
}
|
|
|
|
macro_rules! deserialize_numeric_key {
|
|
($method:ident) => {
|
|
deserialize_numeric_key!($method, deserialize_number);
|
|
};
|
|
|
|
($method:ident, $using:ident) => {
|
|
fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
let mut de = crate::Deserializer::from_str(&self.key);
|
|
|
|
match tri!(de.peek()) {
|
|
Some(b'0'..=b'9' | b'-') => {}
|
|
_ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)),
|
|
}
|
|
|
|
let number = tri!(de.$using(visitor));
|
|
|
|
if tri!(de.peek()).is_some() {
|
|
return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0));
|
|
}
|
|
|
|
Ok(number)
|
|
}
|
|
};
|
|
}
|
|
|
|
impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
|
|
type Error = Error;
|
|
|
|
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
|
|
}
|
|
|
|
deserialize_numeric_key!(deserialize_i8);
|
|
deserialize_numeric_key!(deserialize_i16);
|
|
deserialize_numeric_key!(deserialize_i32);
|
|
deserialize_numeric_key!(deserialize_i64);
|
|
deserialize_numeric_key!(deserialize_u8);
|
|
deserialize_numeric_key!(deserialize_u16);
|
|
deserialize_numeric_key!(deserialize_u32);
|
|
deserialize_numeric_key!(deserialize_u64);
|
|
#[cfg(not(feature = "float_roundtrip"))]
|
|
deserialize_numeric_key!(deserialize_f32);
|
|
deserialize_numeric_key!(deserialize_f64);
|
|
|
|
#[cfg(feature = "float_roundtrip")]
|
|
deserialize_numeric_key!(deserialize_f32, do_deserialize_f32);
|
|
deserialize_numeric_key!(deserialize_i128, do_deserialize_i128);
|
|
deserialize_numeric_key!(deserialize_u128, do_deserialize_u128);
|
|
|
|
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
if self.key == "true" {
|
|
visitor.visit_bool(true)
|
|
} else if self.key == "false" {
|
|
visitor.visit_bool(false)
|
|
} else {
|
|
Err(serde::de::Error::invalid_type(
|
|
Unexpected::Str(&self.key),
|
|
&visitor,
|
|
))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
// Map keys cannot be null.
|
|
visitor.visit_some(self)
|
|
}
|
|
|
|
#[inline]
|
|
fn deserialize_newtype_struct<V>(
|
|
self,
|
|
_name: &'static str,
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
visitor.visit_newtype_struct(self)
|
|
}
|
|
|
|
fn deserialize_enum<V>(
|
|
self,
|
|
name: &'static str,
|
|
variants: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: Visitor<'de>,
|
|
{
|
|
self.key
|
|
.into_deserializer()
|
|
.deserialize_enum(name, variants, visitor)
|
|
}
|
|
|
|
forward_to_deserialize_any! {
|
|
char str string bytes byte_buf unit unit_struct seq tuple tuple_struct
|
|
map struct identifier ignored_any
|
|
}
|
|
}
|
|
|
|
struct KeyClassifier;
|
|
|
|
enum KeyClass {
|
|
Map(String),
|
|
#[cfg(feature = "arbitrary_precision")]
|
|
Number,
|
|
#[cfg(feature = "raw_value")]
|
|
RawValue,
|
|
}
|
|
|
|
impl<'de> DeserializeSeed<'de> for KeyClassifier {
|
|
type Value = KeyClass;
|
|
|
|
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
deserializer.deserialize_str(self)
|
|
}
|
|
}
|
|
|
|
impl<'de> Visitor<'de> for KeyClassifier {
|
|
type Value = KeyClass;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_str("a string key")
|
|
}
|
|
|
|
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
|
|
where
|
|
E: de::Error,
|
|
{
|
|
match s {
|
|
#[cfg(feature = "arbitrary_precision")]
|
|
crate::number::TOKEN => Ok(KeyClass::Number),
|
|
#[cfg(feature = "raw_value")]
|
|
crate::raw::TOKEN => Ok(KeyClass::RawValue),
|
|
_ => Ok(KeyClass::Map(s.to_owned())),
|
|
}
|
|
}
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
|
fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
|
|
where
|
|
E: de::Error,
|
|
{
|
|
match s.as_str() {
|
|
#[cfg(feature = "arbitrary_precision")]
|
|
crate::number::TOKEN => Ok(KeyClass::Number),
|
|
#[cfg(feature = "raw_value")]
|
|
crate::raw::TOKEN => Ok(KeyClass::RawValue),
|
|
_ => Ok(KeyClass::Map(s)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Value {
|
|
#[cold]
|
|
fn invalid_type<E>(&self, exp: &dyn Expected) -> E
|
|
where
|
|
E: serde::de::Error,
|
|
{
|
|
serde::de::Error::invalid_type(self.unexpected(), exp)
|
|
}
|
|
|
|
#[cold]
|
|
fn unexpected(&self) -> Unexpected {
|
|
match self {
|
|
Value::Null => Unexpected::Unit,
|
|
Value::Bool(b) => Unexpected::Bool(*b),
|
|
Value::Number(n) => n.unexpected(),
|
|
Value::String(s) => Unexpected::Str(s),
|
|
Value::Array(_) => Unexpected::Seq,
|
|
Value::Object(_) => Unexpected::Map,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct BorrowedCowStrDeserializer<'de> {
|
|
value: Cow<'de, str>,
|
|
}
|
|
|
|
impl<'de> BorrowedCowStrDeserializer<'de> {
|
|
fn new(value: Cow<'de, str>) -> Self {
|
|
BorrowedCowStrDeserializer { value }
|
|
}
|
|
}
|
|
|
|
impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
|
|
type Error = Error;
|
|
|
|
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: de::Visitor<'de>,
|
|
{
|
|
match self.value {
|
|
Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
|
Cow::Owned(string) => visitor.visit_string(string),
|
|
#[cfg(not(any(feature = "std", feature = "alloc")))]
|
|
Cow::Owned(_) => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn deserialize_enum<V>(
|
|
self,
|
|
_name: &str,
|
|
_variants: &'static [&'static str],
|
|
visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: de::Visitor<'de>,
|
|
{
|
|
visitor.visit_enum(self)
|
|
}
|
|
|
|
forward_to_deserialize_any! {
|
|
bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
|
|
bytes byte_buf option unit unit_struct newtype_struct seq tuple
|
|
tuple_struct map struct identifier ignored_any
|
|
}
|
|
}
|
|
|
|
impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
|
|
type Error = Error;
|
|
type Variant = UnitOnly;
|
|
|
|
fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error>
|
|
where
|
|
T: de::DeserializeSeed<'de>,
|
|
{
|
|
let value = tri!(seed.deserialize(self));
|
|
Ok((value, UnitOnly))
|
|
}
|
|
}
|
|
|
|
struct UnitOnly;
|
|
|
|
impl<'de> de::VariantAccess<'de> for UnitOnly {
|
|
type Error = Error;
|
|
|
|
fn unit_variant(self) -> Result<(), Error> {
|
|
Ok(())
|
|
}
|
|
|
|
fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
|
|
where
|
|
T: de::DeserializeSeed<'de>,
|
|
{
|
|
Err(de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"newtype variant",
|
|
))
|
|
}
|
|
|
|
fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
|
|
where
|
|
V: de::Visitor<'de>,
|
|
{
|
|
Err(de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"tuple variant",
|
|
))
|
|
}
|
|
|
|
fn struct_variant<V>(
|
|
self,
|
|
_fields: &'static [&'static str],
|
|
_visitor: V,
|
|
) -> Result<V::Value, Error>
|
|
where
|
|
V: de::Visitor<'de>,
|
|
{
|
|
Err(de::Error::invalid_type(
|
|
Unexpected::UnitVariant,
|
|
&"struct variant",
|
|
))
|
|
}
|
|
}
|