use alloc::{borrow::Cow, vec::Vec};
use core::iter::FusedIterator;
use crate::{
DuplicateKeys, Limits, Number, Value,
error::{Error, ErrorKind},
lexer, parser, scan,
};
#[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, Copy, Debug, PartialEq, Eq)]
enum State {
Value,
Element,
ArrayFirst,
ArrayNext,
ObjectFirst,
Key,
ObjectNext,
End,
Done,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Container {
Array,
Object,
}
#[derive(Clone, Debug)]
pub struct Reader<'a> {
src: &'a str,
pos: usize,
last: usize,
state: State,
stack: Vec<Container>,
elements: usize,
limits: Limits,
duplicates: DuplicateKeys,
failed: Option<Error>,
skipping: bool,
}
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,
pos: 0,
last: 0,
state: State::Value,
stack: Vec::new(),
elements: 0,
limits,
duplicates,
failed,
skipping: false,
}
}
pub fn next_event(&mut self) -> Result<Option<Event<'a>>, Error> {
if let Some(e) = self.failed {
return Err(e);
}
self.step().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.at_value()? {
return Ok(None);
}
self.skipping = true;
let result = self.skip_value();
self.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.at_value()? {
return Ok(None);
}
let duplicates = self.duplicates;
parser::build(self, duplicates)
.inspect_err(|&e| self.failed = Some(e))
.map(Some)
}
pub fn finish(mut self) -> Result<(), Error> {
while self.next_event()?.is_some() {}
Ok(())
}
#[inline]
#[must_use]
pub fn depth(&self) -> usize {
self.stack.len()
}
#[inline]
#[must_use]
pub fn offset(&self) -> usize {
self.pos
}
#[inline]
#[must_use]
pub fn event_offset(&self) -> usize {
self.last
}
#[inline]
fn bytes(&self) -> &'a [u8] {
self.src.as_bytes()
}
#[inline]
fn skip_whitespace(&mut self) {
let bytes = self.bytes();
while bytes
.get(self.pos)
.copied()
.is_some_and(scan::is_whitespace)
{
self.pos += 1;
}
}
#[inline]
fn end_error(&self) -> Error {
Error::new(ErrorKind::UnexpectedEnd, self.src.len())
}
fn at_value(&mut self) -> Result<bool, Error> {
self.skip_whitespace();
let next = self.bytes().get(self.pos).copied();
Ok(match self.state {
State::Value | State::Element => true,
State::ArrayFirst => next != Some(b']'),
State::ArrayNext if next == Some(b',') => {
self.pos += 1;
self.state = State::Element;
true
}
_ => false,
})
}
fn skip_value(&mut self) -> Result<&'a str, Error> {
let depth = self.stack.len();
let first = self.next_event()?;
let start = self.last;
if matches!(first, Some(Event::StartArray | Event::StartObject)) {
while self.stack.len() > depth {
if self.next_event()?.is_none() {
return Err(self.end_error());
}
}
}
Ok(self.src.get(start..self.pos).unwrap_or(""))
}
#[inline]
fn after_value(&mut self) {
self.state = match self.stack.last() {
None => State::End,
Some(Container::Array) => State::ArrayNext,
Some(Container::Object) => State::ObjectNext,
};
}
#[inline]
fn close(&mut self, at: usize, event: Event<'a>) -> Event<'a> {
self.pos = at + 1;
self.last = at;
let _closed = self.stack.pop();
self.after_value();
event
}
fn step(&mut self) -> Result<Option<Event<'a>>, Error> {
loop {
self.skip_whitespace();
let at = self.pos;
let next = self.bytes().get(at).copied();
let err = |kind| Err(Error::new(kind, at));
match self.state {
State::Value | State::Element | State::ArrayFirst => match next {
None => return Err(self.end_error()),
Some(b']') if self.state == State::ArrayFirst => {
return Ok(Some(self.close(at, Event::EndArray)));
}
Some(b']') if self.state == State::Element => {
return err(ErrorKind::TrailingComma);
}
Some(b) => return self.value(b, at).map(Some),
},
State::ArrayNext => match next {
None => return Err(self.end_error()),
Some(b',') => {
self.pos += 1;
self.state = State::Element;
}
Some(b']') => return Ok(Some(self.close(at, Event::EndArray))),
Some(_) => return err(ErrorKind::ExpectedCommaOrBracket),
},
State::ObjectFirst | State::Key => match next {
None => return Err(self.end_error()),
Some(b'"') => return self.key(at).map(Some),
Some(b'}') if self.state == State::ObjectFirst => {
return Ok(Some(self.close(at, Event::EndObject)));
}
Some(b'}') => return err(ErrorKind::TrailingComma),
Some(_) => return err(ErrorKind::ExpectedKey),
},
State::ObjectNext => match next {
None => return Err(self.end_error()),
Some(b',') => {
self.pos += 1;
self.state = State::Key;
}
Some(b'}') => return Ok(Some(self.close(at, Event::EndObject))),
Some(_) => return err(ErrorKind::ExpectedCommaOrBrace),
},
State::End => {
return match next {
None => {
self.state = State::Done;
Ok(None)
}
Some(_) => err(ErrorKind::TrailingCharacters),
};
}
State::Done => return Ok(None),
}
}
}
#[inline]
fn count_value(&mut self, at: usize) -> Result<(), Error> {
if self.elements >= self.limits.max_elements {
return Err(Error::new(ErrorKind::TooManyElements, at));
}
self.elements += 1;
Ok(())
}
fn value(&mut self, b: u8, at: usize) -> Result<Event<'a>, Error> {
let bytes = self.bytes();
let event = match b {
b'{' | b'[' => {
self.count_value(at)?;
if self.stack.len() >= self.limits.max_depth {
return Err(Error::new(ErrorKind::DepthLimitExceeded, at));
}
self.pos = at + 1;
if b == b'{' {
self.stack.push(Container::Object);
self.state = State::ObjectFirst;
Event::StartObject
} else {
self.stack.push(Container::Array);
self.state = State::ArrayFirst;
Event::StartArray
}
}
b'"' => {
self.count_value(at)?;
Event::String(self.string(at)?)
}
b'-' | b'0'..=b'9' => {
self.count_value(at)?;
let end = lexer::scan_number(bytes, at, self.limits.max_number_bytes)?;
self.pos = end;
self.after_value();
Event::Number(Number::from_valid(self.src.get(at..end).unwrap_or("0")))
}
b't' | b'f' | b'n' => {
self.count_value(at)?;
let (word, event): (&[u8], _) = match b {
b't' => (b"true", Event::Bool(true)),
b'f' => (b"false", Event::Bool(false)),
_ => (b"null", Event::Null),
};
self.pos = lexer::scan_literal(bytes, at, word)?;
self.after_value();
event
}
_ => return Err(Error::new(ErrorKind::ExpectedValue, at)),
};
self.last = at;
Ok(event)
}
fn string(&mut self, at: usize) -> Result<Cow<'a, str>, Error> {
let text = self.string_body(at)?;
self.after_value();
Ok(text)
}
fn key(&mut self, at: usize) -> Result<Event<'a>, Error> {
let key = self.string_body(at)?;
self.skip_whitespace();
match self.bytes().get(self.pos) {
Some(b':') => self.pos += 1,
Some(_) => return Err(Error::new(ErrorKind::ExpectedColon, self.pos)),
None => return Err(self.end_error()),
}
self.state = State::Value;
self.last = at;
Ok(Event::Key(key))
}
fn string_body(&mut self, at: usize) -> Result<Cow<'a, str>, Error> {
let token = lexer::scan_string(self.bytes(), at, self.limits.max_string_bytes)?;
self.pos = token.end;
let body = self.src.get(at + 1..token.end - 1).unwrap_or("");
Ok(if token.escaped && !self.skipping {
Cow::Owned(lexer::decode(body))
} else {
Cow::Borrowed(body)
})
}
}
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.state == State::Done {
return None;
}
match self.next_event() {
Ok(Some(event)) => Some(Ok(event)),
Ok(None) => None,
Err(e) => {
self.state = State::Done;
Some(Err(e))
}
}
}
}
impl FusedIterator for Reader<'_> {}