use alloc::borrow::Cow;
use core::iter::FusedIterator;
use crate::{
DuplicateKeys, Kind, Limits, Number, Value,
error::{Error, ErrorKind},
machine::Machine,
parser,
};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Event<'a> {
StartObject,
EndObject,
StartArray,
EndArray,
Key(Cow<'a, str>),
String(Cow<'a, str>),
Number(Number<'a>),
Bool(bool),
Null,
}
#[derive(Clone, Debug)]
pub struct Reader<'a> {
src: &'a str,
machine: Machine,
failed: Option<Error>,
held: usize,
reading: u32,
}
impl<'a> Reader<'a> {
#[must_use]
pub fn new(text: &'a str) -> Self {
Self::with_config(text, Limits::new(), DuplicateKeys::Error)
}
pub(crate) fn with_config(text: &'a str, limits: Limits, duplicates: DuplicateKeys) -> Self {
let failed = (text.len() > limits.max_input_bytes)
.then(|| Error::new(ErrorKind::InputTooLarge, limits.max_input_bytes));
Self {
src: text,
machine: Machine::new(limits, duplicates, true),
failed,
held: 0,
reading: 0,
}
}
#[must_use]
pub fn documents(mut self) -> Self {
self.machine.documents = true;
self
}
pub fn next_event(&mut self) -> Result<Option<Event<'a>>, Error> {
if let Some(e) = self.failed {
return Err(e);
}
self.machine
.step(self.src)
.inspect_err(|&e| self.failed = Some(e))
}
pub fn read_raw(&mut self) -> Result<Option<&'a str>, Error> {
if let Some(e) = self.failed {
return Err(e);
}
if !self.machine.at_value(self.src)? {
return self.no_value();
}
self.machine.skipping = true;
let result = self.skip_value();
self.machine.skipping = false;
result.map(Some)
}
pub fn read_value(&mut self) -> Result<Option<Value<'a>>, Error> {
if let Some(e) = self.failed {
return Err(e);
}
if !self.machine.at_value(self.src)? {
return self.no_value();
}
let duplicates = self.machine.duplicates;
self.begin_read();
let built = parser::build(self, duplicates);
self.end_read();
built.inspect_err(|&e| self.failed = Some(e)).map(Some)
}
pub fn peek_kind(&mut self) -> Result<Option<Kind>, Error> {
if let Some(e) = self.failed {
return Err(e);
}
Ok(if self.machine.at_value(self.src)? {
self.machine.peek_kind(self.src)
} else {
None
})
}
pub fn find_pointer(&mut self, pointer: &str) -> Result<Option<&'a str>, Error> {
let depth = self.depth();
let found = self.find_in(pointer)?;
if self.machine.duplicates == DuplicateKeys::Last {
while self.depth() > depth {
if self.next_event()?.is_none() {
break;
}
}
} else if self.machine.duplicates == DuplicateKeys::Error {
while self.depth() > depth {
if self.next_event()?.is_none() {
break;
}
}
if depth == 0 && !self.machine.documents {
self.read_to_end()?;
}
}
Ok(found)
}
fn find_in(&mut self, pointer: &str) -> Result<Option<&'a str>, Error> {
if pointer.is_empty() {
return self.read_raw();
}
match pointer.strip_prefix('/') {
Some(tokens) => self.find_tokens(tokens),
None => Ok(None),
}
}
fn find_tokens(&mut self, mut tokens: &str) -> Result<Option<&'a str>, Error> {
loop {
let (token, more) = match tokens.split_once('/') {
Some((token, more)) => (token, Some(more)),
None => (tokens, None),
};
let Some(token) = crate::value::unescape_pointer_token(token) else {
return Ok(None);
};
match self.peek_kind()? {
Some(Kind::Object) if self.machine.duplicates == DuplicateKeys::Last => {
let Some(member) = self.last_member(&token)? else {
return Ok(None);
};
let Some(more) = more else {
return Ok(Some(member));
};
let mut inner =
Reader::with_config(member, self.machine.limits, DuplicateKeys::Last);
return inner.find_tokens(more);
}
Some(Kind::Object) => {
let _start = self.next_event()?;
loop {
match self.next_event()? {
Some(Event::Key(key)) if key == token => break,
Some(Event::Key(_)) => {
let _skipped = self.read_raw()?;
}
_ => return Ok(None),
}
}
}
Some(Kind::Array) => {
let Some(index) = crate::value::array_index(&token) else {
return Ok(None);
};
let _start = self.next_event()?;
for _ in 0..index {
if self.read_raw()?.is_none() {
return Ok(None);
}
}
if self.peek_kind()?.is_none() {
return Ok(None);
}
}
_ => return Ok(None),
}
match more {
Some(more) => tokens = more,
None => return self.read_raw(),
}
}
}
fn last_member(&mut self, key: &str) -> Result<Option<&'a str>, Error> {
let _start = self.next_event()?;
let mut found = None;
while let Some(Event::Key(name)) = self.next_event()? {
let hit = name == key;
let value = self.read_raw()?;
if hit {
found = value;
}
}
Ok(found)
}
pub fn finish(mut self) -> Result<(), Error> {
self.read_to_end()
}
fn no_value<T>(&mut self) -> Result<Option<T>, Error> {
self.machine
.check_trailing(self.src)
.inspect_err(|&e| self.failed = Some(e))?;
Ok(None)
}
#[inline]
pub(crate) fn read_to_end(&mut self) -> Result<(), Error> {
while self.next_event()?.is_some() {}
Ok(())
}
#[inline]
#[must_use]
pub fn depth(&self) -> usize {
self.machine.depth()
}
#[inline]
#[must_use]
pub fn offset(&self) -> usize {
self.machine.pos
}
#[inline]
#[must_use]
pub fn event_offset(&self) -> usize {
self.machine.last
}
pub(crate) const fn with_numbers(mut self, numbers: crate::Numbers) -> Self {
self.machine.numbers = numbers;
self
}
#[inline]
pub(crate) const fn number_policy(&self) -> crate::Numbers {
self.machine.numbers
}
#[inline]
pub(crate) fn at_a_value(&mut self) -> Result<bool, Error> {
if let Some(e) = self.failed {
return Err(e);
}
self.machine.at_value(self.src)
}
#[inline]
pub(crate) fn enter(&mut self, object: bool) -> Result<bool, Error> {
if let Some(e) = self.failed {
return Err(e);
}
self.machine
.enter(self.src, object)
.inspect_err(|&e| self.failed = Some(e))
}
pub(crate) fn key_at(&self, quote: usize) -> alloc::string::String {
crate::machine::key_text(self.src, quote).into_owned()
}
#[inline]
pub(crate) fn at_item(&mut self) -> Result<bool, Error> {
if let Some(e) = self.failed {
return Err(e);
}
match self.machine.at_item(self.src) {
Some(more) => Ok(more),
None => self.machine.at_value(self.src),
}
}
#[inline]
pub(crate) fn begin_read(&mut self) {
if self.reading == 0 {
self.held = 0;
}
self.reading += 1;
}
#[inline]
pub(crate) fn end_read(&mut self) {
self.reading = self.reading.saturating_sub(1);
}
#[inline]
pub(crate) const fn held(&self) -> usize {
self.held
}
#[inline]
pub(crate) fn set_held(&mut self, held: usize) {
self.held = held;
}
#[inline]
pub(crate) const fn max_memory(&self) -> usize {
self.machine.limits.max_memory
}
#[inline]
pub(crate) fn charge(&mut self, bytes: usize, at: usize) -> Result<(), Error> {
let held = self.held.saturating_add(bytes);
if held > self.max_memory() {
return Err(Error::new(ErrorKind::MemoryLimitExceeded, at));
}
self.held = held;
Ok(())
}
#[inline]
pub(crate) fn duplicate_policy(&self) -> DuplicateKeys {
self.machine.duplicates
}
fn skip_value(&mut self) -> Result<&'a str, Error> {
let depth = self.machine.depth();
let first = self.next_event()?;
let start = self.machine.last;
if matches!(first, Some(Event::StartArray | Event::StartObject)) {
while self.machine.depth() > depth {
if self.next_event()?.is_none() {
return Err(Error::new(ErrorKind::UnexpectedEnd, self.src.len()));
}
}
}
Ok(self.src.get(start..self.machine.pos).unwrap_or(""))
}
}
impl<'a> Iterator for Reader<'a> {
type Item = Result<Event<'a>, Error>;
fn next(&mut self) -> Option<Self::Item> {
if self.failed.is_some() && self.machine.is_done() {
return None;
}
match self.next_event() {
Ok(Some(event)) => Some(Ok(event)),
Ok(None) => None,
Err(e) => {
self.machine.finish_iteration();
Some(Err(e))
}
}
}
}
impl FusedIterator for Reader<'_> {}