use std::fmt;
use std::marker::PhantomData;
use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
use serde::de::{
self, DeserializeSeed, Deserializer, EnumAccess, IgnoredAny, MapAccess, SeqAccess, Unexpected, VariantAccess,
Visitor,
};
pub trait TypeFirst<'de>: Sized {
const TAG: &'static str;
const EXPECTING: &'static str;
fn tagged<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
fn named<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
}
pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
where
T: TypeFirst<'de>,
D: Deserializer<'de>,
{
deserializer.deserialize_any(Object(PhantomData))
}
struct Object<T>(PhantomData<T>);
impl<'de, T: TypeFirst<'de>> Visitor<'de> for Object<T> {
type Value = T;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(T::EXPECTING)
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<T, A::Error> {
match map.next_key_seed(KeySeed(T::TAG))? {
Some(Key::Tag) => {}
Some(Key::Other(key)) => return T::tagged(MapAccessDeserializer::new(Replay::new(Some(key), None, map))),
None => return T::tagged(MapAccessDeserializer::new(Replay::new(None, None, map))),
}
let tag = map.next_value_seed(TagValue)?;
let mut deferred = false;
let read = T::named(Named { map: &mut map, tag: T::TAG, value: &tag, deferred: &mut deferred });
if !deferred {
return read;
}
T::tagged(MapAccessDeserializer::new(Replay::new(Some(Scalar::Str(T::TAG)), Some(tag), map)))
}
fn visit_seq<S: SeqAccess<'de>>(self, seq: S) -> Result<T, S::Error> {
T::tagged(SeqAccessDeserializer::new(seq))
}
}
struct Named<'a, 'de, A> {
map: &'a mut A,
tag: &'static str,
value: &'a Scalar<'de>,
deferred: &'a mut bool,
}
impl<'a, 'de, A: MapAccess<'de>> Named<'a, 'de, A> {
fn defer<T>(self) -> Result<T, A::Error> {
*self.deferred = true;
Err(de::Error::custom("a variant read through serde's buffer"))
}
}
impl<'a, 'de, A: MapAccess<'de>> Deserializer<'de> for Named<'a, 'de, A> {
type Error = A::Error;
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, A::Error> {
visitor.visit_enum(self)
}
serde::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 enum identifier ignored_any
}
}
impl<'a, 'de, A: MapAccess<'de>> EnumAccess<'de> for Named<'a, 'de, A> {
type Error = A::Error;
type Variant = Self;
fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self), A::Error> {
let variant = seed.deserialize(ScalarRef(self.value, PhantomData::<A::Error>))?;
Ok((variant, self))
}
}
impl<'a, 'de, A: MapAccess<'de>> VariantAccess<'de> for Named<'a, 'de, A> {
type Error = A::Error;
fn unit_variant(self) -> Result<(), A::Error> {
loop {
match self.map.next_key_seed(KeySeed(self.tag))? {
None => return Ok(()),
Some(Key::Tag) => return Err(de::Error::duplicate_field(self.tag)),
Some(Key::Other(_)) => {
self.map.next_value::<IgnoredAny>()?;
}
}
}
}
fn struct_variant<V: Visitor<'de>>(
self,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, A::Error> {
visitor.visit_map(Rest { map: self.map, tag: self.tag })
}
fn newtype_variant_seed<S: DeserializeSeed<'de>>(self, _seed: S) -> Result<S::Value, A::Error> {
self.defer()
}
fn tuple_variant<V: Visitor<'de>>(self, _len: usize, _visitor: V) -> Result<V::Value, A::Error> {
self.defer()
}
}
struct Rest<'a, A> {
map: &'a mut A,
tag: &'static str,
}
impl<'a, 'de, A: MapAccess<'de>> MapAccess<'de> for Rest<'a, A> {
type Error = A::Error;
fn next_key_seed<K: DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>, A::Error> {
match self.map.next_key_seed(KeySeed(self.tag))? {
None => Ok(None),
Some(Key::Tag) => Err(de::Error::duplicate_field(self.tag)),
Some(Key::Other(key)) => seed.deserialize(ScalarDe(key, PhantomData)).map(Some),
}
}
fn next_value_seed<V: DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value, A::Error> {
self.map.next_value_seed(seed)
}
fn size_hint(&self) -> Option<usize> {
self.map.size_hint()
}
}
struct Replay<'de, A> {
key: Option<Scalar<'de>>,
value: Option<Scalar<'de>>,
map: A,
}
impl<'de, A> Replay<'de, A> {
fn new(key: Option<Scalar<'de>>, value: Option<Scalar<'de>>, map: A) -> Self {
Replay { key, value, map }
}
}
impl<'de, A: MapAccess<'de>> MapAccess<'de> for Replay<'de, A> {
type Error = A::Error;
fn next_key_seed<K: DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>, A::Error> {
match self.key.take() {
Some(key) => seed.deserialize(ScalarDe(key, PhantomData)).map(Some),
None => self.map.next_key_seed(seed),
}
}
fn next_value_seed<V: DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value, A::Error> {
match self.value.take() {
Some(value) => seed.deserialize(ScalarDe(value, PhantomData)),
None => self.map.next_value_seed(seed),
}
}
fn size_hint(&self) -> Option<usize> {
self.map.size_hint().map(|n| n + usize::from(self.key.is_some()))
}
}
#[derive(Clone, Copy)]
struct KeySeed(&'static str);
enum Key<'de> {
Tag,
Other(Scalar<'de>),
}
impl<'de> DeserializeSeed<'de> for KeySeed {
type Value = Key<'de>;
fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Key<'de>, D::Error> {
deserializer.deserialize_any(self)
}
}
impl<'de> Visitor<'de> for KeySeed {
type Value = Key<'de>;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "a type tag `{}` or any other value", self.0)
}
fn visit_borrowed_str<E: de::Error>(self, v: &'de str) -> Result<Key<'de>, E> {
Ok(if v == self.0 { Key::Tag } else { Key::Other(Scalar::Str(v)) })
}
fn visit_str<E: de::Error>(self, v: &str) -> Result<Key<'de>, E> {
Ok(if v == self.0 { Key::Tag } else { Key::Other(Scalar::String(v.to_owned())) })
}
fn visit_string<E: de::Error>(self, v: String) -> Result<Key<'de>, E> {
Ok(if v == self.0 { Key::Tag } else { Key::Other(Scalar::String(v)) })
}
fn visit_borrowed_bytes<E: de::Error>(self, v: &'de [u8]) -> Result<Key<'de>, E> {
Ok(if v == self.0.as_bytes() { Key::Tag } else { Key::Other(Scalar::Bytes(v)) })
}
fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Key<'de>, E> {
Ok(if v == self.0.as_bytes() { Key::Tag } else { Key::Other(Scalar::ByteBuf(v.to_vec())) })
}
fn visit_byte_buf<E: de::Error>(self, v: Vec<u8>) -> Result<Key<'de>, E> {
Ok(if v == self.0.as_bytes() { Key::Tag } else { Key::Other(Scalar::ByteBuf(v)) })
}
fn visit_u64<E: de::Error>(self, v: u64) -> Result<Key<'de>, E> {
Ok(Key::Other(Scalar::U64(v)))
}
fn visit_i64<E: de::Error>(self, v: i64) -> Result<Key<'de>, E> {
Ok(Key::Other(Scalar::I64(v)))
}
fn visit_f64<E: de::Error>(self, v: f64) -> Result<Key<'de>, E> {
Ok(Key::Other(Scalar::F64(v)))
}
fn visit_bool<E: de::Error>(self, v: bool) -> Result<Key<'de>, E> {
Ok(Key::Other(Scalar::Bool(v)))
}
fn visit_char<E: de::Error>(self, v: char) -> Result<Key<'de>, E> {
Ok(Key::Other(Scalar::Char(v)))
}
fn visit_unit<E: de::Error>(self) -> Result<Key<'de>, E> {
Ok(Key::Other(Scalar::Unit))
}
}
struct TagValue;
impl<'de> DeserializeSeed<'de> for TagValue {
type Value = Scalar<'de>;
fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Scalar<'de>, D::Error> {
deserializer.deserialize_identifier(self)
}
}
impl<'de> Visitor<'de> for TagValue {
type Value = Scalar<'de>;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("variant identifier")
}
fn visit_u64<E: de::Error>(self, v: u64) -> Result<Scalar<'de>, E> {
Ok(Scalar::U64(v))
}
fn visit_borrowed_str<E: de::Error>(self, v: &'de str) -> Result<Scalar<'de>, E> {
Ok(Scalar::Str(v))
}
fn visit_str<E: de::Error>(self, v: &str) -> Result<Scalar<'de>, E> {
Ok(Scalar::String(v.to_owned()))
}
fn visit_string<E: de::Error>(self, v: String) -> Result<Scalar<'de>, E> {
Ok(Scalar::String(v))
}
fn visit_borrowed_bytes<E: de::Error>(self, v: &'de [u8]) -> Result<Scalar<'de>, E> {
Ok(Scalar::Bytes(v))
}
fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Scalar<'de>, E> {
Ok(Scalar::ByteBuf(v.to_vec()))
}
fn visit_byte_buf<E: de::Error>(self, v: Vec<u8>) -> Result<Scalar<'de>, E> {
Ok(Scalar::ByteBuf(v))
}
}
enum Scalar<'de> {
Str(&'de str),
String(String),
Bytes(&'de [u8]),
ByteBuf(Vec<u8>),
U64(u64),
I64(i64),
F64(f64),
Bool(bool),
Char(char),
Unit,
}
impl Scalar<'_> {
fn unexpected(&self) -> Unexpected<'_> {
match self {
Scalar::Str(v) => Unexpected::Str(v),
Scalar::String(v) => Unexpected::Str(v),
Scalar::Bytes(v) => Unexpected::Bytes(v),
Scalar::ByteBuf(v) => Unexpected::Bytes(v),
Scalar::U64(v) => Unexpected::Unsigned(*v),
Scalar::I64(v) => Unexpected::Signed(*v),
Scalar::F64(v) => Unexpected::Float(*v),
Scalar::Bool(v) => Unexpected::Bool(*v),
Scalar::Char(v) => Unexpected::Char(*v),
Scalar::Unit => Unexpected::Unit,
}
}
}
struct ScalarDe<'de, E>(Scalar<'de>, PhantomData<E>);
impl<'de, E: de::Error> Deserializer<'de> for ScalarDe<'de, E> {
type Error = E;
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, E> {
match self.0 {
Scalar::Str(v) => visitor.visit_borrowed_str(v),
Scalar::String(v) => visitor.visit_string(v),
Scalar::Bytes(v) => visitor.visit_borrowed_bytes(v),
Scalar::ByteBuf(v) => visitor.visit_byte_buf(v),
Scalar::U64(v) => visitor.visit_u64(v),
Scalar::I64(v) => visitor.visit_i64(v),
Scalar::F64(v) => visitor.visit_f64(v),
Scalar::Bool(v) => visitor.visit_bool(v),
Scalar::Char(v) => visitor.visit_char(v),
Scalar::Unit => visitor.visit_unit(),
}
}
fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, E> {
match self.0 {
Scalar::Str(v) => visitor.visit_borrowed_str(v),
Scalar::String(v) => visitor.visit_string(v),
Scalar::Bytes(v) => visitor.visit_borrowed_bytes(v),
Scalar::ByteBuf(v) => visitor.visit_byte_buf(v),
Scalar::U64(v) => visitor.visit_u64(v),
ref other => Err(de::Error::invalid_type(other.unexpected(), &visitor)),
}
}
serde::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 enum ignored_any
}
}
struct ScalarRef<'a, 'de, E>(&'a Scalar<'de>, PhantomData<E>);
impl<'de, E: de::Error> Deserializer<'de> for ScalarRef<'_, 'de, E> {
type Error = E;
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, E> {
self.deserialize_identifier(visitor)
}
fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, E> {
match *self.0 {
Scalar::Str(v) => visitor.visit_borrowed_str(v),
Scalar::String(ref v) => visitor.visit_str(v),
Scalar::Bytes(v) => visitor.visit_borrowed_bytes(v),
Scalar::ByteBuf(ref v) => visitor.visit_bytes(v),
Scalar::U64(v) => visitor.visit_u64(v),
ref other => Err(de::Error::invalid_type(other.unexpected(), &visitor)),
}
}
serde::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 enum ignored_any
}
}