#[cfg(target_has_atomic = "ptr")]
use alloc::sync::Arc;
use alloc::{
borrow::Cow,
boxed::Box,
collections::{BTreeMap, BTreeSet, VecDeque},
format,
rc::Rc,
string::String,
vec::Vec,
};
use core::fmt::{self, Write as _};
use crate::{
Array, DuplicateKeys, Kind, Limits, Number, Numbers, Object, Parser, Reader, ToJson, Value,
ValueWriter, Written,
error::{Error, ErrorKind},
reader::Event,
};
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum PathSegment {
Key(String),
Index(usize),
}
impl fmt::Display for PathSegment {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Key(key) => f.write_str(key),
Self::Index(index) => write!(f, "{index}"),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum DecodeErrorKind {
Syntax(ErrorKind),
WrongType {
expected: &'static str,
found: Kind,
},
OutOfRange {
expected: &'static str,
},
StringNotBorrowable,
WrongLength {
expected: usize,
found: usize,
},
MissingField(&'static str),
UnknownField,
DuplicateField,
InvalidValue(&'static str),
Custom(Cow<'static, str>),
}
impl fmt::Display for DecodeErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Syntax(kind) => write!(f, "{kind}"),
Self::WrongType { expected, found } => write!(f, "expected {expected}, found {found}"),
Self::OutOfRange { expected } => write!(f, "number out of range for {expected}"),
Self::StringNotBorrowable => {
f.write_str("a string with escapes cannot be borrowed as `&str`")
}
Self::WrongLength { expected, found } => {
write!(f, "expected {expected} items, found {found}")
}
Self::MissingField(name) => write!(f, "missing field `{name}`"),
Self::UnknownField => f.write_str("unknown field"),
Self::DuplicateField => f.write_str("duplicate field"),
Self::InvalidValue(expected) => write!(f, "invalid value: expected {expected}"),
Self::Custom(message) => f.write_str(message),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
struct Inner {
kind: DecodeErrorKind,
offset: usize,
path: Vec<PathSegment>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[must_use]
pub struct DecodeError(Box<Inner>);
impl DecodeError {
#[cold]
pub fn new(kind: DecodeErrorKind, offset: usize) -> Self {
Self(Box::new(Inner {
kind,
offset,
path: Vec::new(),
}))
}
#[cold]
pub fn wrong_type(expected: &'static str, found: Kind, offset: usize) -> Self {
Self::new(DecodeErrorKind::WrongType { expected, found }, offset)
}
#[cold]
pub fn invalid_value(expected: &'static str, offset: usize) -> Self {
Self::new(DecodeErrorKind::InvalidValue(expected), offset)
}
pub fn custom(message: impl Into<Cow<'static, str>>, offset: usize) -> Self {
Self::new(DecodeErrorKind::Custom(message.into()), offset)
}
#[cold]
pub fn missing_field(name: &'static str, offset: usize) -> Self {
Self::new(DecodeErrorKind::MissingField(name), offset)
}
#[cold]
pub fn at_key(mut self, key: impl Into<String>) -> Self {
self.0.path.insert(0, PathSegment::Key(key.into()));
self
}
#[cold]
pub fn at_index(mut self, index: usize) -> Self {
self.0.path.insert(0, PathSegment::Index(index));
self
}
#[must_use]
pub fn kind(&self) -> &DecodeErrorKind {
&self.0.kind
}
#[must_use]
pub fn offset(&self) -> usize {
self.0.offset
}
#[must_use]
pub fn path(&self) -> &[PathSegment] {
&self.0.path
}
#[must_use]
pub fn pointer(&self) -> String {
let mut out = String::new();
for segment in &self.0.path {
out.push('/');
match segment {
PathSegment::Key(key) => {
for ch in key.chars() {
match ch {
'~' => out.push_str("~0"),
'/' => out.push_str("~1"),
_ => out.push(ch),
}
}
}
PathSegment::Index(index) => out.push_str(&format!("{index}")),
}
}
out
}
#[must_use]
pub fn line_col(&self, input: impl AsRef<[u8]>) -> (usize, usize) {
let at = crate::error::locate(input.as_ref(), self.0.offset);
(at.line + 1, at.chars + 1)
}
#[must_use]
pub fn utf16_position(&self, input: impl AsRef<[u8]>) -> (usize, usize) {
let at = crate::error::locate(input.as_ref(), self.0.offset);
(at.line, at.utf16)
}
#[must_use]
pub fn syntax_error(&self) -> Option<Error> {
match self.0.kind {
DecodeErrorKind::Syntax(kind) => Some(Error::new(kind, self.0.offset)),
_ => None,
}
}
pub(crate) fn shifted(mut self, by: usize) -> Self {
self.0.offset += by;
self
}
}
impl From<Error> for DecodeError {
#[cold]
fn from(e: Error) -> Self {
Self::new(DecodeErrorKind::Syntax(e.kind()), e.offset())
}
}
impl fmt::Display for DecodeError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} at byte {}", self.0.kind, self.0.offset)?;
if !self.0.path.is_empty() {
f.write_str(" (at ")?;
for segment in &self.0.path {
f.write_char('/')?;
match segment {
PathSegment::Key(key) => write_message_key(f, key)?,
PathSegment::Index(index) => write!(f, "{index}")?,
}
}
f.write_char(')')?;
}
Ok(())
}
}
const MESSAGE_KEY_CHARS: usize = 64;
fn write_message_key(f: &mut fmt::Formatter<'_>, key: &str) -> fmt::Result {
for (count, ch) in key.chars().enumerate() {
if count == MESSAGE_KEY_CHARS {
return f.write_str("...");
}
match ch {
'~' => f.write_str("~0")?,
'/' => f.write_str("~1")?,
'\\' => f.write_str("\\\\")?,
_ if hides_text(ch) => write!(f, "{}", ch.escape_unicode())?,
_ => f.write_char(ch)?,
}
}
Ok(())
}
fn hides_text(ch: char) -> bool {
ch.is_control()
|| matches!(
ch,
'\u{2028}'
| '\u{2029}'
| '\u{200e}'
| '\u{200f}'
| '\u{202a}'..='\u{202e}'
| '\u{2066}'..='\u{2069}'
)
}
impl core::error::Error for DecodeError {}
pub trait FromJson<'de>: Sized {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError>;
#[inline]
fn absent() -> Option<Self> {
None
}
}
pub trait FromJsonKey<'de>: Sized {
fn from_json_key(key: Cow<'de, str>) -> Result<Self, DecodeErrorKind>;
}
pub(crate) fn decode_value<'de, T: FromJson<'de>>(
reader: &mut Reader<'de>,
) -> Result<T, DecodeError> {
let depth = reader.depth();
let value = T::from_json(reader)?;
while reader.depth() > depth {
if reader.next_event()?.is_none() {
break;
}
}
Ok(value)
}
impl<'a> Reader<'a> {
pub fn decode<T: FromJson<'a>>(&mut self) -> Result<T, DecodeError> {
self.begin_read();
let value = decode_value(self);
self.end_read();
value
}
#[inline]
fn hold(&mut self, bytes: usize) -> Result<(), DecodeError> {
let at = self.offset();
self.charge(bytes, at).map_err(DecodeError::from)
}
pub fn read_object(&mut self) -> Result<ObjectReader<'_, 'a>, DecodeError> {
let start = self.open(Kind::Object, "an object")?;
Ok(ObjectReader {
reader: self,
start,
key_offset: start,
pending: false,
done: false,
})
}
pub fn read_array(&mut self) -> Result<ArrayReader<'_, 'a>, DecodeError> {
let start = self.open(Kind::Array, "an array")?;
Ok(ArrayReader {
reader: self,
start,
index: 0,
done: false,
})
}
pub fn read_raw_value(&mut self) -> Result<Option<crate::RawValue<'a>>, Error> {
Ok(self.read_raw()?.map(crate::RawValue::trusted))
}
fn open(&mut self, kind: Kind, expected: &'static str) -> Result<usize, DecodeError> {
if self.enter(kind == Kind::Object)? {
return Ok(self.event_offset());
}
match self.peek_kind()? {
Some(found) if found == kind => {}
Some(found) => return Err(DecodeError::wrong_type(expected, found, self.offset())),
None if !self.at_a_value()? => {
return Err(DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedValue),
self.offset(),
));
}
None => {}
}
match self.next_event()? {
Some(Event::StartObject | Event::StartArray) => Ok(self.event_offset()),
Some(other) => Err(DecodeError::wrong_type(
expected,
event_kind(&other),
self.event_offset(),
)),
None => Err(Error::new(ErrorKind::UnexpectedEnd, self.offset()).into()),
}
}
#[inline]
fn scalar(&mut self, expected: &'static str) -> Result<(Event<'a>, usize), DecodeError> {
match self.next_event() {
Ok(Some(
event @ (Event::String(_) | Event::Number(_) | Event::Bool(_) | Event::Null),
)) => Ok((event, self.event_offset())),
other => Err(self.not_a_scalar(other, expected)),
}
}
#[cold]
#[inline(never)]
fn not_a_scalar(
&self,
read: Result<Option<Event<'a>>, Error>,
expected: &'static str,
) -> DecodeError {
match read {
Err(e) => e.into(),
Ok(Some(event @ (Event::StartArray | Event::StartObject))) => {
DecodeError::wrong_type(expected, event_kind(&event), self.event_offset())
}
Ok(Some(_)) => DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedValue),
self.event_offset(),
),
Ok(None) => DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedValue),
self.offset(),
),
}
}
}
fn event_kind(event: &Event<'_>) -> Kind {
match event {
Event::StartObject | Event::EndObject | Event::Key(_) => Kind::Object,
Event::StartArray | Event::EndArray => Kind::Array,
Event::String(_) => Kind::String,
Event::Number(_) => Kind::Number,
Event::Bool(_) => Kind::Bool,
Event::Null => Kind::Null,
}
}
pub struct ObjectReader<'r, 'de> {
reader: &'r mut Reader<'de>,
start: usize,
key_offset: usize,
pending: bool,
done: bool,
}
impl<'de> ObjectReader<'_, 'de> {
pub fn next_key(&mut self) -> Result<Option<Cow<'de, str>>, DecodeError> {
if self.done {
return Ok(None);
}
if self.pending {
self.skip()?;
}
match self.reader.next_event()? {
Some(Event::Key(key)) => {
self.key_offset = self.reader.event_offset();
self.pending = true;
Ok(Some(key))
}
Some(Event::EndObject) => {
self.done = true;
Ok(None)
}
_ => Err(DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedKey),
self.reader.event_offset(),
)),
}
}
#[inline]
pub fn value<T: FromJson<'de>>(&mut self) -> Result<T, DecodeError> {
self.value_with(T::from_json)
}
pub fn value_with<T>(
&mut self,
read: impl FnOnce(&mut Reader<'de>) -> Result<T, DecodeError>,
) -> Result<T, DecodeError> {
self.pending = false;
let depth = self.reader.depth();
let result = read(self.reader).and_then(|value| {
while self.reader.depth() > depth {
if self.reader.next_event()?.is_none() {
break;
}
}
Ok(value)
});
result.map_err(|e| self.in_member(e))
}
#[cold]
#[inline(never)]
fn in_member(&self, e: DecodeError) -> DecodeError {
e.at_key(self.reader.key_at(self.key_offset))
}
pub fn field<T: FromJson<'de>>(&mut self, slot: &mut Option<T>) -> Result<(), DecodeError> {
if slot.is_some() {
match self.reader.duplicate_policy() {
DuplicateKeys::First => return self.skip(),
DuplicateKeys::Last | DuplicateKeys::KeepAll => {}
_ => {
let e = DecodeError::new(DecodeErrorKind::DuplicateField, self.key_offset);
return Err(self.in_member(e));
}
}
}
*slot = Some(self.value()?);
Ok(())
}
pub fn skip(&mut self) -> Result<(), DecodeError> {
self.raw().map(|_| ())
}
pub fn raw(&mut self) -> Result<&'de str, DecodeError> {
self.pending = false;
match self.reader.read_raw() {
Ok(Some(text)) => Ok(text),
Ok(None) => {
let e = DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedValue),
self.reader.offset(),
);
Err(self.in_member(e))
}
Err(e) => Err(self.in_member(e.into())),
}
}
pub fn unknown_field(&self) -> DecodeError {
self.in_member(DecodeError::new(
DecodeErrorKind::UnknownField,
self.key_offset,
))
}
pub fn required<T: FromJson<'de>>(
&self,
slot: Option<T>,
name: &'static str,
) -> Result<T, DecodeError> {
slot.or_else(T::absent)
.ok_or_else(|| DecodeError::missing_field(name, self.start))
}
#[must_use]
pub fn offset(&self) -> usize {
self.start
}
}
pub struct ArrayReader<'r, 'de> {
reader: &'r mut Reader<'de>,
start: usize,
index: usize,
done: bool,
}
impl<'de> ArrayReader<'_, 'de> {
#[inline(always)]
fn more(&mut self) -> Result<bool, DecodeError> {
if self.done {
return Ok(false);
}
if self.reader.at_item()? {
return Ok(true);
}
match self.reader.next_event()? {
Some(Event::EndArray) => {
self.done = true;
Ok(false)
}
_ => Err(DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedCommaOrBracket),
self.reader.event_offset(),
)),
}
}
#[inline]
pub fn next_item<T: FromJson<'de>>(&mut self) -> Result<Option<T>, DecodeError> {
self.next_with(T::from_json)
}
pub fn next_with<T>(
&mut self,
read: impl FnOnce(&mut Reader<'de>) -> Result<T, DecodeError>,
) -> Result<Option<T>, DecodeError> {
if !self.more()? {
return Ok(None);
}
let index = self.index;
self.index += 1;
let depth = self.reader.depth();
let result = read(self.reader).and_then(|value| {
while self.reader.depth() > depth {
if self.reader.next_event()?.is_none() {
break;
}
}
Ok(value)
});
result.map(Some).map_err(|e| e.at_index(index))
}
pub fn skip(&mut self) -> Result<bool, DecodeError> {
let index = self.index;
if !self.more()? {
return Ok(false);
}
self.index += 1;
match self.reader.read_raw() {
Ok(_) => Ok(true),
Err(e) => Err(DecodeError::from(e).at_index(index)),
}
}
pub fn end(mut self) -> Result<(), DecodeError> {
let expected = self.index;
if !self.more()? {
return Ok(());
}
while self.skip()? {}
Err(DecodeError::new(
DecodeErrorKind::WrongLength {
expected,
found: self.index,
},
self.start,
))
}
#[must_use]
pub fn index(&self) -> usize {
self.index
}
#[must_use]
pub fn offset(&self) -> usize {
self.start
}
}
pub fn from_str<'de, T: FromJson<'de>>(text: &'de str) -> Result<T, DecodeError> {
Parser::new().decode(text)
}
pub fn from_bytes<'de, T: FromJson<'de>>(bytes: &'de [u8]) -> Result<T, DecodeError> {
Parser::new().decode_bytes(bytes)
}
pub fn from_value<T: for<'de> FromJson<'de>>(value: &Value<'_>) -> Result<T, DecodeError> {
let text = crate::to_string(value);
from_str(&text)
}
#[must_use]
pub fn to_value<T: ToJson + ?Sized>(value: &T) -> Value<'static> {
let text = crate::to_string(value);
Parser::new()
.limits(Limits::unlimited())
.duplicate_keys(DuplicateKeys::KeepAll)
.parse(&text)
.map(Value::into_owned)
.unwrap_or_default()
}
impl Parser {
pub fn decode<'de, T: FromJson<'de>>(&self, text: &'de str) -> Result<T, DecodeError> {
let mut reader = self.reader(text);
let value = reader.decode()?;
reader.read_to_end()?;
Ok(value)
}
pub fn decode_bytes<'de, T: FromJson<'de>>(&self, bytes: &'de [u8]) -> Result<T, DecodeError> {
let mut reader = self.reader_bytes(bytes)?;
let value = reader.decode()?;
reader.read_to_end()?;
Ok(value)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Nullable<T> {
#[default]
Absent,
Null,
Value(T),
}
impl<T> Nullable<T> {
#[inline]
pub fn into_option(self) -> Option<T> {
match self {
Self::Value(value) => Some(value),
Self::Absent | Self::Null => None,
}
}
#[inline]
pub const fn as_ref(&self) -> Nullable<&T> {
match self {
Self::Value(value) => Nullable::Value(value),
Self::Null => Nullable::Null,
Self::Absent => Nullable::Absent,
}
}
#[inline]
#[must_use]
pub const fn is_null(&self) -> bool {
matches!(self, Self::Null)
}
}
impl<'de, T: FromJson<'de>> FromJson<'de> for Nullable<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
if reader.peek_kind()? == Some(Kind::Null) {
let _null = reader.next_event()?;
Ok(Self::Null)
} else {
decode_value(reader).map(Self::Value)
}
}
#[inline]
fn absent() -> Option<Self> {
Some(Self::Absent)
}
}
impl<T: ToJson> ToJson for Nullable<T> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
match self {
Self::Value(value) => value.to_json(out),
Self::Absent | Self::Null => out.null(),
}
}
#[inline]
fn is_absent(&self) -> bool {
matches!(self, Self::Absent)
}
}
impl<'de> FromJson<'de> for bool {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
match reader.scalar("a boolean")? {
(Event::Bool(b), _) => Ok(b),
(other, at) => Err(DecodeError::wrong_type("a boolean", event_kind(&other), at)),
}
}
}
#[inline]
fn number<'de>(
reader: &mut Reader<'de>,
name: &'static str,
) -> Result<(Number<'de>, usize), DecodeError> {
match reader.scalar(name)? {
(Event::Number(n), at) => Ok((n, at)),
(other, at) => Err(DecodeError::wrong_type(name, event_kind(&other), at)),
}
}
#[cold]
#[inline(never)]
fn whole_value<T: TryFrom<i128>>(
n: &Number<'_>,
lenient: bool,
at: usize,
expected: &'static str,
) -> Result<T, DecodeError> {
lenient
.then(|| n.whole_value())
.flatten()
.and_then(|w| T::try_from(w).ok())
.ok_or_else(|| DecodeError::new(DecodeErrorKind::OutOfRange { expected }, at))
}
macro_rules! from_json_integer {
($($t:ty => $via:ident),* $(,)?) => {$(
impl<'de> FromJson<'de> for $t {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let lenient = reader.number_policy() == Numbers::WholeValues;
let (n, at) = number(reader, stringify!($t))?;
match n.$via().and_then(|wide| <$t>::try_from(wide).ok()) {
Some(value) => Ok(value),
None => whole_value(&n, lenient, at, stringify!($t)),
}
}
}
)*};
}
from_json_integer!(
i8 => as_i64, i16 => as_i64, i32 => as_i64, i64 => as_i64, isize => as_i128, i128 => as_i128,
u8 => as_u64, u16 => as_u64, u32 => as_u64, u64 => as_u64, usize => as_u128, u128 => as_u128,
);
impl<'de> FromJson<'de> for f64 {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let (n, at) = number(reader, "f64")?;
n.as_f64()
.ok_or_else(|| DecodeError::new(DecodeErrorKind::OutOfRange { expected: "f64" }, at))
}
}
impl<'de> FromJson<'de> for f32 {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let (n, at) = number(reader, "f32")?;
n.as_f32()
.ok_or_else(|| DecodeError::new(DecodeErrorKind::OutOfRange { expected: "f32" }, at))
}
}
#[inline]
fn string<'de>(
reader: &mut Reader<'de>,
name: &'static str,
) -> Result<(Cow<'de, str>, usize), DecodeError> {
match reader.scalar(name)? {
(Event::String(s), at) => Ok((s, at)),
(other, at) => Err(DecodeError::wrong_type(name, event_kind(&other), at)),
}
}
impl<'de> FromJson<'de> for Cow<'de, str> {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let (s, _) = string(reader, "a string")?;
if let Cow::Owned(decoded) = &s {
reader.hold(decoded.capacity())?;
}
Ok(s)
}
}
impl<'de> FromJson<'de> for &'de str {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
match string(reader, "a string")? {
(Cow::Borrowed(s), _) => Ok(s),
(Cow::Owned(_), at) => Err(DecodeError::new(DecodeErrorKind::StringNotBorrowable, at)),
}
}
}
impl<'de> FromJson<'de> for String {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let (s, _) = string(reader, "a string")?;
reader.hold(match &s {
Cow::Owned(decoded) => decoded.capacity(),
Cow::Borrowed(text) => text.len(),
})?;
Ok(s.into_owned())
}
}
impl<'de> FromJson<'de> for Box<str> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
String::from_json(reader).map(String::into_boxed_str)
}
}
impl<'de> FromJson<'de> for char {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let (s, at) = string(reader, "a character")?;
let mut chars = s.chars();
match (chars.next(), chars.next()) {
(Some(c), None) => Ok(c),
_ => Err(DecodeError::invalid_value("a single character", at)),
}
}
}
impl<'de> FromJson<'de> for () {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
match reader.scalar("null")? {
(Event::Null, _) => Ok(()),
(other, at) => Err(DecodeError::wrong_type("null", event_kind(&other), at)),
}
}
}
impl<'de, T: FromJson<'de>> FromJson<'de> for Option<T> {
#[inline]
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
if reader.peek_kind()? == Some(Kind::Null) {
let _null = reader.next_event()?;
Ok(None)
} else {
decode_value(reader).map(Some)
}
}
#[inline]
fn absent() -> Option<Self> {
Some(None)
}
}
impl<'de, T: FromJson<'de>> FromJson<'de> for Box<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let value = T::from_json(reader)?;
reader.hold(size_of::<T>())?;
Ok(Box::new(value))
}
fn absent() -> Option<Self> {
T::absent().map(Box::new)
}
}
impl<'de, T: FromJson<'de>> FromJson<'de> for Rc<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let value = T::from_json(reader)?;
reader.hold(size_of::<T>() + 2 * size_of::<usize>())?;
Ok(Rc::new(value))
}
fn absent() -> Option<Self> {
T::absent().map(Rc::new)
}
}
#[cfg(target_has_atomic = "ptr")]
impl<'de, T: FromJson<'de>> FromJson<'de> for Arc<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let value = T::from_json(reader)?;
reader.hold(size_of::<T>() + 2 * size_of::<usize>())?;
Ok(Arc::new(value))
}
fn absent() -> Option<Self> {
T::absent().map(Arc::new)
}
}
#[derive(Clone, Copy)]
enum Cost {
Buffer(usize),
PerItem(usize),
}
const fn per_entry(entry: usize) -> usize {
2 * entry + size_of::<usize>()
}
fn items<'de, T: FromJson<'de>>(
reader: &mut Reader<'de>,
expected: &'static str,
cost: Cost,
mut push: impl FnMut(T),
) -> Result<(), DecodeError> {
let start = reader.open(Kind::Array, expected)?;
let mut array = ArrayReader {
reader,
start,
index: 0,
done: false,
};
let mut capacity = 0usize;
while let Some(item) = array.next_item()? {
let more = match cost {
Cost::Buffer(size) if array.index > capacity => {
let grown = capacity.saturating_mul(2).max(4);
let bytes = (grown - capacity).saturating_mul(size);
capacity = grown;
bytes
}
Cost::Buffer(_) => 0,
Cost::PerItem(bytes) => bytes,
};
array.reader.hold(more)?;
push(item);
}
Ok(())
}
impl<'de, T: FromJson<'de>> FromJson<'de> for Vec<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut out = Vec::new();
items(reader, "an array", Cost::Buffer(size_of::<T>()), |item| {
out.push(item)
})?;
Ok(out)
}
}
impl<'de, T: FromJson<'de>> FromJson<'de> for Box<[T]> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
Vec::from_json(reader).map(Vec::into_boxed_slice)
}
}
impl<'de, T: FromJson<'de>> FromJson<'de> for VecDeque<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut out = VecDeque::new();
items(reader, "an array", Cost::Buffer(size_of::<T>()), |item| {
out.push_back(item);
})?;
Ok(out)
}
}
impl<'de, T: FromJson<'de> + Ord> FromJson<'de> for BTreeSet<T> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut out = BTreeSet::new();
items(
reader,
"an array",
Cost::PerItem(per_entry(size_of::<T>())),
|item| {
let _new = out.insert(item);
},
)?;
Ok(out)
}
}
#[cfg(feature = "std")]
impl<'de, T, S> FromJson<'de> for std::collections::HashSet<T, S>
where
T: FromJson<'de> + Eq + core::hash::Hash,
S: core::hash::BuildHasher + Default,
{
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut out = Self::default();
items(
reader,
"an array",
Cost::PerItem(per_entry(size_of::<T>())),
|item| {
let _new = out.insert(item);
},
)?;
Ok(out)
}
}
impl<'de, T: FromJson<'de>, const N: usize> FromJson<'de> for [T; N] {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut array = reader.read_array()?;
let mut out = Vec::with_capacity(N.min(1024));
while out.len() < N {
match array.next_item()? {
Some(item) => out.push(item),
None => {
return Err(DecodeError::new(
DecodeErrorKind::WrongLength {
expected: N,
found: out.len(),
},
array.offset(),
));
}
}
}
array.end()?;
out.try_into().map_err(|_unreachable: Vec<T>| {
DecodeError::new(
DecodeErrorKind::WrongLength {
expected: N,
found: N,
},
0,
)
})
}
}
macro_rules! from_json_tuple {
($(($len:literal: $($name:ident),+))*) => {$(
impl<'de, $($name: FromJson<'de>),+> FromJson<'de> for ($($name,)+) {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut array = reader.read_array()?;
let tuple = ($(
match array.next_item::<$name>()? {
Some(item) => item,
None => {
return Err(DecodeError::new(
DecodeErrorKind::WrongLength { expected: $len, found: array.index() },
array.offset(),
));
}
},
)+);
array.end()?;
Ok(tuple)
}
}
)*};
}
from_json_tuple! {
(1: A)
(2: A, B)
(3: A, B, C)
(4: A, B, C, D)
(5: A, B, C, D, E)
(6: A, B, C, D, E, F)
(7: A, B, C, D, E, F, G)
(8: A, B, C, D, E, F, G, H)
}
trait Map<K, V> {
fn has(&self, key: &K) -> bool;
fn put(&mut self, key: K, value: V);
}
impl<K: Ord, V> Map<K, V> for BTreeMap<K, V> {
fn has(&self, key: &K) -> bool {
self.contains_key(key)
}
fn put(&mut self, key: K, value: V) {
let _old = self.insert(key, value);
}
}
#[cfg(feature = "std")]
impl<K: Eq + core::hash::Hash, V, S: core::hash::BuildHasher> Map<K, V>
for std::collections::HashMap<K, V, S>
{
fn has(&self, key: &K) -> bool {
self.contains_key(key)
}
fn put(&mut self, key: K, value: V) {
let _old = self.insert(key, value);
}
}
fn members<'de, K: FromJsonKey<'de>, V: FromJson<'de>>(
reader: &mut Reader<'de>,
map: &mut impl Map<K, V>,
) -> Result<(), DecodeError> {
let policy = reader.duplicate_policy();
let mut object = reader.read_object()?;
while let Some(text) = object.next_key()? {
let key = K::from_json_key(text)
.map_err(|kind| object.in_member(DecodeError::new(kind, object.key_offset)))?;
if map.has(&key) {
match policy {
DuplicateKeys::First => {
object.skip()?;
continue;
}
DuplicateKeys::Last | DuplicateKeys::KeepAll => {}
_ => {
let e = DecodeError::new(DecodeErrorKind::DuplicateField, object.key_offset);
return Err(object.in_member(e));
}
}
}
let value = object.value()?;
object.reader.hold(per_entry(size_of::<(K, V)>()))?;
map.put(key, value);
}
Ok(())
}
impl<'de, K: FromJsonKey<'de> + Ord, V: FromJson<'de>> FromJson<'de> for BTreeMap<K, V> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut out = BTreeMap::new();
members(reader, &mut out)?;
Ok(out)
}
}
#[cfg(feature = "std")]
impl<'de, K, V, S> FromJson<'de> for std::collections::HashMap<K, V, S>
where
K: FromJsonKey<'de> + Eq + core::hash::Hash,
V: FromJson<'de>,
S: core::hash::BuildHasher + Default,
{
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
let mut out = Self::default();
members(reader, &mut out)?;
Ok(out)
}
}
impl<'de> FromJsonKey<'de> for String {
#[inline]
fn from_json_key(key: Cow<'de, str>) -> Result<Self, DecodeErrorKind> {
Ok(key.into_owned())
}
}
impl<'de> FromJsonKey<'de> for Box<str> {
#[inline]
fn from_json_key(key: Cow<'de, str>) -> Result<Self, DecodeErrorKind> {
Ok(key.into_owned().into_boxed_str())
}
}
impl<'de> FromJsonKey<'de> for Cow<'de, str> {
#[inline]
fn from_json_key(key: Cow<'de, str>) -> Result<Self, DecodeErrorKind> {
Ok(key)
}
}
impl<'de> FromJsonKey<'de> for &'de str {
#[inline]
fn from_json_key(key: Cow<'de, str>) -> Result<Self, DecodeErrorKind> {
match key {
Cow::Borrowed(key) => Ok(key),
Cow::Owned(_) => Err(DecodeErrorKind::StringNotBorrowable),
}
}
}
impl<'de> FromJson<'de> for Value<'de> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
match reader.read_value()? {
Some(value) => Ok(value),
None => Err(DecodeError::new(
DecodeErrorKind::Syntax(ErrorKind::ExpectedValue),
reader.offset(),
)),
}
}
}
impl<'de> FromJson<'de> for Number<'de> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
number(reader, "a number").map(|(n, _)| n)
}
}
fn tree<'de>(
reader: &mut Reader<'de>,
kind: Kind,
expected: &'static str,
) -> Result<Value<'de>, DecodeError> {
match reader.peek_kind()? {
Some(found) if found != kind => {
Err(DecodeError::wrong_type(expected, found, reader.offset()))
}
_ => Value::from_json(reader),
}
}
impl<'de> FromJson<'de> for Array<'de> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
match tree(reader, Kind::Array, "an array")? {
Value::Array(array) => Ok(array),
other => Err(DecodeError::wrong_type(
"an array",
other.kind(),
reader.event_offset(),
)),
}
}
}
impl<'de> FromJson<'de> for Object<'de> {
fn from_json(reader: &mut Reader<'de>) -> Result<Self, DecodeError> {
match tree(reader, Kind::Object, "an object")? {
Value::Object(object) => Ok(object),
other => Err(DecodeError::wrong_type(
"an object",
other.kind(),
reader.event_offset(),
)),
}
}
}