use std::fmt;
use serde::de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor};
use serde::{Deserialize, Deserializer};
use serde_json::{Map, Value};
const MAX_DEPTH: usize = 64;
pub(super) struct Document(pub Value);
impl<'de> Deserialize<'de> for Document {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Depth(MAX_DEPTH).deserialize(deserializer).map(Self)
}
}
struct Depth(usize);
impl<'de> DeserializeSeed<'de> for Depth {
type Value = Value;
fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Value, D::Error> {
if self.0 == 0 {
return Err(de::Error::custom(super::errors::DEPTH));
}
deserializer.deserialize_any(self)
}
}
impl<'de> Visitor<'de> for Depth {
type Value = Value;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(super::errors::VALUE)
}
fn visit_unit<E: de::Error>(self) -> Result<Value, E> {
Ok(Value::Null)
}
fn visit_bool<E: de::Error>(self, value: bool) -> Result<Value, E> {
Ok(Value::Bool(value))
}
fn visit_i64<E: de::Error>(self, value: i64) -> Result<Value, E> {
Ok(value.into())
}
fn visit_u64<E: de::Error>(self, value: u64) -> Result<Value, E> {
Ok(value.into())
}
fn visit_f64<E: de::Error>(self, value: f64) -> Result<Value, E> {
Ok(value.into())
}
fn visit_str<E: de::Error>(self, value: &str) -> Result<Value, E> {
Ok(Value::String(value.to_owned()))
}
fn visit_string<E: de::Error>(self, value: String) -> Result<Value, E> {
Ok(Value::String(value))
}
fn visit_seq<A: SeqAccess<'de>>(self, mut sequence: A) -> Result<Value, A::Error> {
let mut values = Vec::new();
while let Some(value) = sequence.next_element_seed(Depth(self.0 - 1))? {
values.push(value);
}
Ok(Value::Array(values))
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Value, A::Error> {
let mut values = Map::new();
while let Some(key) = map.next_key::<String>()? {
values.insert(key, map.next_value_seed(Depth(self.0 - 1))?);
}
Ok(Value::Object(values))
}
}