use super::{KeyDeserializer, NodeDeserializer};
use crate::Error;
use crate::parse::{Collection, ObjectKeys, Parser};
use serde_core::de::{self, DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor};
use std::borrow::Cow;
pub(crate) fn read<'de, T: de::Deserialize<'de>>(source: &'de str) -> Option<T> {
let mut stream = Stream {
parser: Parser::new(source),
source,
keys: Vec::with_capacity(32),
depth: 0,
failed: false,
};
stream.parser.start_document().ok()?;
let value = T::deserialize(&mut stream).ok()?;
stream.parser.end_document().ok()?;
(!stream.failed).then_some(value)
}
#[cold]
fn failure<T>(_: T) -> Error {
de::Error::custom("the document is read again through the tree")
}
struct Stream<'de> {
parser: Parser<'de>,
source: &'de str,
keys: Vec<Cow<'de, str>>,
depth: usize,
failed: bool,
}
enum Next {
Scalar,
Array,
Object,
BareObject,
}
impl<'de> Stream<'de> {
#[inline]
fn next(&self) -> Next {
match self.parser.peek() {
Some(b'[') => Next::Array,
Some(b'{') => Next::Object,
_ if self.depth == 0 => Next::BareObject,
_ => Next::Scalar,
}
}
fn watch<T>(&mut self, step: impl FnOnce(&mut Self) -> Result<T, Error>) -> Result<T, Error> {
let result = step(self);
self.failed |= result.is_err();
result
}
#[inline]
fn node(&mut self) -> Result<NodeDeserializer<'de>, Error> {
let node = match self.next() {
Next::BareObject => self.parser.parse_bare_object(),
_ => self.parser.parse_value(self.depth + 1),
}
.map_err(failure)?;
Ok(NodeDeserializer {
node,
source: Some(self.source),
})
}
fn visit_array<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value, Error> {
self.depth += 1;
let start = self.parser.open_braced(self.depth).map_err(failure)?;
let mut items = Items {
stream: self,
start,
is_done: false,
};
let value = visitor.visit_seq(&mut items)?;
if !items.is_done && items.has_item()? {
return Err(failure(()));
}
self.depth -= 1;
Ok(value)
}
fn visit_object<V: Visitor<'de>>(
&mut self,
visitor: V,
is_bare: bool,
) -> Result<V::Value, Error> {
self.depth += 1;
let start = if is_bare {
None
} else {
Some(self.parser.open_braced(self.depth).map_err(failure)?)
};
let mut members = Members {
keys: ObjectKeys::new(&self.keys),
stream: self,
start,
is_first: is_bare,
is_done: false,
has_value: false,
};
let value = visitor.visit_map(&mut members)?;
if members.has_value || (!members.is_done && members.has_entry()?) {
return Err(failure(()));
}
members.keys.end(&mut members.stream.keys);
self.depth -= 1;
Ok(value)
}
fn read_value<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Result<T::Value, Error> {
let start = self.parser.index;
let value = seed.deserialize(&mut *self)?;
if self.parser.index == start {
return Err(failure(()));
}
Ok(value)
}
fn first_key_is(&self, key: &str, is_bare: bool) -> bool {
let mut parser = self.parser.clone();
if !is_bare && parser.open_braced(0).is_err() {
return false;
}
parser
.parse_entry_key()
.is_ok_and(|(first, _)| first == key)
}
}
macro_rules! deserialize_from_tree {
($($method:ident)*) => {
$(
fn $method<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| this.node()?.$method(visitor))
}
)*
};
}
impl<'de> Deserializer<'de> for &mut Stream<'de> {
type Error = Error;
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| match this.next() {
Next::Array => this.visit_array(visitor),
Next::Object => this.visit_object(visitor, false),
Next::BareObject => this.visit_object(visitor, true),
Next::Scalar => this.node()?.deserialize_any(visitor),
})
}
fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| match this.next() {
Next::Array => this.visit_array(visitor),
_ => this.node()?.deserialize_bytes(visitor),
})
}
fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.deserialize_bytes(visitor)
}
fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| match this.next() {
Next::Scalar => this.node()?.deserialize_option(visitor),
_ => visitor.visit_some(this),
})
}
fn deserialize_unit_struct<V: Visitor<'de>>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Error> {
self.deserialize_unit(visitor)
}
fn deserialize_newtype_struct<V: Visitor<'de>>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Error> {
self.watch(|this| match (name, this.next()) {
(crate::value::TOKEN, Next::Array | Next::Object | Next::BareObject) => {
this.deserialize_any(visitor)
}
(
crate::value::TOKEN
| crate::spanned::TOKEN
| crate::instant::TOKEN
| crate::duration::TOKEN,
_,
) => this.node()?.deserialize_newtype_struct(name, visitor),
_ => visitor.visit_newtype_struct(this),
})
}
fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| match this.next() {
Next::Array => this.visit_array(visitor),
_ => this.node()?.deserialize_seq(visitor),
})
}
fn deserialize_tuple<V: Visitor<'de>>(
self,
_length: usize,
visitor: V,
) -> Result<V::Value, Error> {
self.deserialize_seq(visitor)
}
fn deserialize_tuple_struct<V: Visitor<'de>>(
self,
_name: &'static str,
_length: usize,
visitor: V,
) -> Result<V::Value, Error> {
self.deserialize_seq(visitor)
}
fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| match this.next() {
Next::Object => this.visit_object(visitor, false),
Next::BareObject => this.visit_object(visitor, true),
_ => this.node()?.deserialize_map(visitor),
})
}
fn deserialize_struct<V: Visitor<'de>>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error> {
self.watch(|this| {
let is_bare = match this.next() {
Next::Object => false,
Next::BareObject => true,
_ => return this.node()?.deserialize_struct(name, fields, visitor),
};
if let [tag, _] = fields
&& !this.first_key_is(tag, is_bare)
{
return this.node()?.deserialize_struct(name, fields, visitor);
}
this.visit_object(visitor, is_bare)
})
}
fn deserialize_enum<V: Visitor<'de>>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error> {
self.watch(|this| this.node()?.deserialize_enum(name, variants, visitor))
}
fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
self.watch(|this| {
match this.next() {
Next::Array => {
this.visit_array(de::IgnoredAny)?;
}
Next::Object => {
this.visit_object(de::IgnoredAny, false)?;
}
Next::BareObject => {
this.visit_object(de::IgnoredAny, true)?;
}
Next::Scalar => {
this.node()?.deserialize_ignored_any(de::IgnoredAny)?;
}
}
visitor.visit_unit()
})
}
deserialize_from_tree! {
deserialize_bool deserialize_i8 deserialize_i16 deserialize_i32 deserialize_i64 deserialize_i128
deserialize_u8 deserialize_u16 deserialize_u32 deserialize_u64 deserialize_u128
deserialize_f32 deserialize_f64 deserialize_char deserialize_str deserialize_string
deserialize_unit deserialize_identifier
}
}
struct Items<'a, 'de> {
stream: &'a mut Stream<'de>,
start: usize,
is_done: bool,
}
impl<'de> Items<'_, 'de> {
#[inline]
fn has_item(&mut self) -> Result<bool, Error> {
self.stream
.parser
.next_braced_item(Collection::Array, self.start)
.map_err(failure)
}
fn next_item<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>, Error> {
if self.is_done || !self.has_item()? {
self.is_done = true;
return Ok(None);
}
let value = self.stream.read_value(seed)?;
self.stream
.parser
.after_braced_item(Collection::Array, self.start)
.map_err(failure)?;
Ok(Some(value))
}
}
impl<'de> SeqAccess<'de> for Items<'_, 'de> {
type Error = Error;
fn next_element_seed<T: DeserializeSeed<'de>>(
&mut self,
seed: T,
) -> Result<Option<T::Value>, Error> {
if self.stream.failed {
return Ok(None);
}
let result = self.next_item(seed);
self.stream.failed |= result.is_err();
result
}
}
struct Members<'a, 'de> {
stream: &'a mut Stream<'de>,
start: Option<usize>,
keys: ObjectKeys<'de>,
is_first: bool,
is_done: bool,
has_value: bool,
}
impl<'de> Members<'_, 'de> {
#[inline]
fn has_entry(&mut self) -> Result<bool, Error> {
let parser = &mut self.stream.parser;
match self.start {
Some(start) => parser.next_braced_item(Collection::Object, start),
None if std::mem::take(&mut self.is_first) => Ok(true),
None => parser.next_bare_entry(),
}
.map_err(failure)
}
#[inline]
fn insert(&mut self, key: Cow<'de, str>) -> Result<(), Error> {
if self.keys.insert(&mut self.stream.keys, key) {
Ok(())
} else {
Err(failure(()))
}
}
fn next_key<K: DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>, Error> {
if self.has_value {
return Err(failure(()));
}
if self.is_done || !self.has_entry()? {
self.is_done = true;
return Ok(None);
}
let (key, _) = self.stream.parser.parse_entry_key().map_err(failure)?;
self.insert(key.clone())?;
self.has_value = true;
seed.deserialize(KeyDeserializer { key }).map(Some)
}
fn next_value<V: DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value, Error> {
if !std::mem::take(&mut self.has_value) {
return Err(failure(()));
}
let value = self.stream.read_value(seed)?;
if let Some(start) = self.start {
self.stream
.parser
.after_braced_item(Collection::Object, start)
.map_err(failure)?;
}
Ok(value)
}
}
impl<'de> MapAccess<'de> for Members<'_, 'de> {
type Error = Error;
fn next_key_seed<K: DeserializeSeed<'de>>(
&mut self,
seed: K,
) -> Result<Option<K::Value>, Error> {
if self.stream.failed {
return Ok(None);
}
let result = self.next_key(seed);
self.stream.failed |= result.is_err();
result
}
fn next_value_seed<V: DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value, Error> {
let result = self.next_value(seed);
self.stream.failed |= result.is_err();
result
}
}