use crate::reader::{Buffers, ErrorKind, ParseError};
use crate::scalars::{self, StrPart};
use crate::stage1;
#[doc(alias = "get")]
#[doc(alias = "dig")]
#[doc(alias = "json_pointer")]
pub fn pointer<'j>(
input: &'j str,
pointer: &str,
bufs: &mut Buffers,
) -> Result<Option<&'j str>, ParseError> {
unsafe { pointer_utf8_unchecked(input.as_bytes(), pointer, bufs) }
}
pub unsafe fn pointer_utf8_unchecked<'j>(
input: &'j [u8],
pointer: &str,
bufs: &mut Buffers,
) -> Result<Option<&'j str>, ParseError> {
if !pointer.is_empty() && !pointer.starts_with('/') {
return Err(ParseError {
offset: 0,
kind: ErrorKind::InvalidPointer,
});
}
let range = unsafe { resolve(input, pointer, &mut bufs.scratch) }?;
Ok(range.map(|(start, end)| unsafe { std::str::from_utf8_unchecked(&input[start..end]) }))
}
#[inline(always)]
fn skip_ws(input: &[u8], mut i: usize) -> usize {
while let Some(&b) = input.get(i) {
if matches!(b, b' ' | b'\t' | b'\n' | b'\r') {
i += 1;
} else {
break;
}
}
i
}
unsafe fn value_end(input: &[u8], i: usize, scratch: &mut Vec<u8>) -> Result<usize, ParseError> {
let eof = || ParseError::unexpected_end(input.len());
match *input.get(i).ok_or_else(eof)? {
b'"' => unsafe { scalars::parse_string(input, i, scratch) }
.map(|(_, end)| end)
.map_err(|e| ParseError::scalar(e, i)),
b'-' | b'0'..=b'9' => scalars::parse_number(input, i)
.map(|(_, end)| end)
.map_err(|e| ParseError::scalar(e, i)),
b't' | b'f' | b'n' => scalars::parse_literal(input, i)
.map(|(_, end)| end)
.map_err(|e| ParseError::scalar(e, i)),
b'{' | b'[' => stage1::container_end(input, i).ok_or_else(eof),
_ => Err(ParseError::unexpected_character(i)),
}
}
unsafe fn resolve(
input: &[u8],
pointer: &str,
scratch: &mut Vec<u8>,
) -> Result<Option<(usize, usize)>, ParseError> {
let mut i = skip_ws(input, 0);
if pointer.is_empty() {
let end = unsafe { value_end(input, i, scratch) }?;
let trail = skip_ws(input, end);
if trail != input.len() {
return Err(ParseError::trailing_characters(trail));
}
return Ok(Some((i, end)));
}
let mut tokens = pointer.split('/').skip(1).peekable();
while let Some(token) = tokens.next() {
let is_last = tokens.peek().is_none();
let value_pos = match input.get(i).copied() {
None => return Err(ParseError::unexpected_end(input.len())),
Some(b'{') => {
unsafe { descend_object(input, i, token, scratch) }?
}
Some(b'[') => {
unsafe { descend_array(input, i, token, scratch) }?
}
Some(_) => None,
};
let Some(value_pos) = value_pos else {
return Ok(None);
};
i = value_pos;
if is_last {
let end = unsafe { value_end(input, i, scratch) }?;
return Ok(Some((i, end)));
}
}
unreachable!("the token loop returns on its last iteration");
}
#[doc(alias = "get_many")]
pub fn pointers<'j>(
input: &'j str,
pointers: &[&str],
bufs: &mut Buffers,
) -> Result<Vec<Option<&'j str>>, ParseError> {
unsafe { pointers_utf8_unchecked(input.as_bytes(), pointers, bufs) }
}
pub unsafe fn pointers_utf8_unchecked<'j>(
input: &'j [u8],
pointers: &[&str],
bufs: &mut Buffers,
) -> Result<Vec<Option<&'j str>>, ParseError> {
let arena: Vec<Vec<Token<'_>>> = pointers
.iter()
.map(|ptr| {
if ptr.is_empty() {
Vec::new()
} else {
ptr.split('/').skip(1).map(Token::parse).collect()
}
})
.collect();
let mut queries: Vec<Query<'_>> = Vec::with_capacity(pointers.len());
for (id, ptr) in pointers.iter().enumerate() {
if !ptr.is_empty() && !ptr.starts_with('/') {
return Err(ParseError {
offset: 0,
kind: ErrorKind::InvalidPointer,
});
}
queries.push(Query {
id,
tokens: &arena[id],
});
}
let mut results: Vec<Option<(usize, usize)>> = vec![None; pointers.len()];
let mut remaining = queries.len();
let start = skip_ws(input, 0);
unsafe {
resolve_set(
input,
start,
&queries,
&mut results,
&mut remaining,
&mut bufs.scratch,
)
}?;
if let Some(root) = pointers.iter().position(|p| p.is_empty()) {
let (_, end) = results[root].expect("the root pointer always matches");
let trail = skip_ws(input, end);
if trail != input.len() {
return Err(ParseError::trailing_characters(trail));
}
}
Ok(results
.into_iter()
.map(|r| r.map(|(s, e)| unsafe { std::str::from_utf8_unchecked(&input[s..e]) }))
.collect())
}
#[derive(Clone, Copy)]
struct Query<'p> {
id: usize,
tokens: &'p [Token<'p>],
}
struct Token<'p> {
text: std::borrow::Cow<'p, str>,
index: Option<usize>,
}
impl<'p> Token<'p> {
fn parse(raw: &'p str) -> Token<'p> {
let valid_index = !raw.is_empty()
&& raw.bytes().all(|b| b.is_ascii_digit())
&& (raw == "0" || !raw.starts_with('0'));
Token {
text: if raw.contains('~') {
raw.replace("~1", "/").replace("~0", "~").into()
} else {
raw.into()
},
index: if valid_index { raw.parse().ok() } else { None },
}
}
}
unsafe fn resolve_set(
input: &[u8],
i: usize,
queries: &[Query<'_>],
results: &mut Vec<Option<(usize, usize)>>,
remaining: &mut usize,
scratch: &mut Vec<u8>,
) -> Result<Option<usize>, ParseError> {
let deeper: Vec<Query<'_>> = queries
.iter()
.copied()
.filter(|q| !q.tokens.is_empty())
.collect();
let end = match input.get(i).copied() {
None => return Err(ParseError::unexpected_end(input.len())),
Some(b'{') if !deeper.is_empty() => {
let walked = unsafe { walk_object(input, i, &deeper, results, remaining, scratch) }?;
match walked {
Some(end) => end,
None => return Ok(None),
}
}
Some(b'[') if !deeper.is_empty() => {
let walked = unsafe { walk_array(input, i, &deeper, results, remaining, scratch) }?;
match walked {
Some(end) => end,
None => return Ok(None),
}
}
_ => unsafe { value_end(input, i, scratch) }?,
};
for q in queries {
if q.tokens.is_empty() {
results[q.id] = Some((i, end));
*remaining -= 1;
}
}
if *remaining == 0 {
return Ok(None);
}
Ok(Some(end))
}
unsafe fn walk_object(
input: &[u8],
mut i: usize,
deeper: &[Query<'_>],
results: &mut Vec<Option<(usize, usize)>>,
remaining: &mut usize,
scratch: &mut Vec<u8>,
) -> Result<Option<usize>, ParseError> {
i = skip_ws(input, i + 1);
if input.get(i) == Some(&b'}') {
return Ok(Some(i + 1)); }
let mut live: Vec<Query<'_>> = deeper.to_vec();
loop {
if input.get(i) != Some(&b'"') {
return Err(ParseError::expected("'\"'", i));
}
let (part, key_end) = unsafe { scalars::parse_string(input, i, scratch) }
.map_err(|e| ParseError::scalar(e, i))?;
let mut advanced: Vec<Query<'_>> = Vec::new();
if let StrPart::Borrowed(k) | StrPart::Decoded(k) = part {
live.retain(|q| {
let hit = q.tokens[0].text == k;
if hit {
advanced.push(Query {
id: q.id,
tokens: &q.tokens[1..],
});
}
!hit
});
}
i = skip_ws(input, key_end);
if input.get(i) != Some(&b':') {
return Err(ParseError::expected("':'", i));
}
i = skip_ws(input, i + 1);
let value_past = if advanced.is_empty() {
unsafe { value_end(input, i, scratch) }?
} else {
match unsafe { resolve_set(input, i, &advanced, results, remaining, scratch) }? {
Some(end) => end,
None => return Ok(None),
}
};
i = skip_ws(input, value_past);
match input.get(i) {
Some(b',') => i = skip_ws(input, i + 1),
Some(b'}') => return Ok(Some(i + 1)),
Some(_) => return Err(ParseError::expected("',' or '}'", i)),
None => return Err(ParseError::unexpected_end(input.len())),
}
}
}
unsafe fn walk_array(
input: &[u8],
mut i: usize,
deeper: &[Query<'_>],
results: &mut Vec<Option<(usize, usize)>>,
remaining: &mut usize,
scratch: &mut Vec<u8>,
) -> Result<Option<usize>, ParseError> {
i = skip_ws(input, i + 1);
if input.get(i) == Some(&b']') {
return Ok(Some(i + 1)); }
let max_wanted = deeper.iter().filter_map(|q| q.tokens[0].index).max();
let mut element = 0usize;
loop {
let advanced: Vec<Query<'_>> = deeper
.iter()
.filter(|q| q.tokens[0].index == Some(element))
.map(|q| Query {
id: q.id,
tokens: &q.tokens[1..],
})
.collect();
let value_past = if advanced.is_empty() {
unsafe { value_end(input, i, scratch) }?
} else {
match unsafe { resolve_set(input, i, &advanced, results, remaining, scratch) }? {
Some(end) => end,
None => return Ok(None),
}
};
i = skip_ws(input, value_past);
match input.get(i) {
Some(b',') => i = skip_ws(input, i + 1),
Some(b']') => return Ok(Some(i + 1)),
Some(_) => return Err(ParseError::expected("',' or ']'", i)),
None => return Err(ParseError::unexpected_end(input.len())),
}
element += 1;
if max_wanted.is_some_and(|m| element > m) {
loop {
let past = unsafe { value_end(input, i, scratch) }?;
i = skip_ws(input, past);
match input.get(i) {
Some(b',') => i = skip_ws(input, i + 1),
Some(b']') => return Ok(Some(i + 1)),
Some(_) => return Err(ParseError::expected("',' or ']'", i)),
None => return Err(ParseError::unexpected_end(input.len())),
}
}
}
}
}
unsafe fn descend_object(
input: &[u8],
mut i: usize,
token: &str,
scratch: &mut Vec<u8>,
) -> Result<Option<usize>, ParseError> {
let unescaped: std::borrow::Cow<'_, str> = if token.contains('~') {
token.replace("~1", "/").replace("~0", "~").into()
} else {
token.into()
};
i = skip_ws(input, i + 1);
if input.get(i) == Some(&b'}') {
return Ok(None); }
loop {
if input.get(i) != Some(&b'"') {
return Err(ParseError::expected("'\"'", i));
}
let (part, key_end) = unsafe { scalars::parse_string(input, i, scratch) }
.map_err(|e| ParseError::scalar(e, i))?;
let matched = match part {
StrPart::Borrowed(k) | StrPart::Decoded(k) => k == unescaped,
StrPart::DecodedRaw(_) => false,
};
i = skip_ws(input, key_end);
if input.get(i) != Some(&b':') {
return Err(ParseError::expected("':'", i));
}
i = skip_ws(input, i + 1);
if matched {
return Ok(Some(i)); }
let value_past = unsafe { value_end(input, i, scratch) }?;
i = skip_ws(input, value_past);
match input.get(i) {
Some(b',') => i = skip_ws(input, i + 1),
Some(b'}') => return Ok(None), Some(_) => return Err(ParseError::expected("',' or '}'", i)),
None => return Err(ParseError::unexpected_end(input.len())),
}
}
}
unsafe fn descend_array(
input: &[u8],
mut i: usize,
token: &str,
scratch: &mut Vec<u8>,
) -> Result<Option<usize>, ParseError> {
let valid = !token.is_empty()
&& token.bytes().all(|b| b.is_ascii_digit())
&& (token == "0" || !token.starts_with('0'));
let target = if valid {
token.parse::<usize>().ok()
} else {
None
};
let Some(target) = target else {
return Ok(None);
};
i = skip_ws(input, i + 1);
if input.get(i) == Some(&b']') {
return Ok(None); }
for _ in 0..target {
let value_past = unsafe { value_end(input, i, scratch) }?;
i = skip_ws(input, value_past);
match input.get(i) {
Some(b',') => i = skip_ws(input, i + 1),
Some(b']') => return Ok(None), Some(_) => return Err(ParseError::expected("',' or ']'", i)),
None => return Err(ParseError::unexpected_end(input.len())),
}
}
Ok(Some(i))
}
#[cfg(test)]
mod tests {
use super::*;
fn get<'j>(doc: &'j str, ptr: &str) -> Option<&'j str> {
let mut bufs = Buffers::new();
pointer(doc, ptr, &mut bufs).unwrap()
}
#[test]
fn rfc6901_examples() {
let doc = r#"{
"foo": ["bar", "baz"],
"": 0,
"a/b": 1,
"c%d": 2,
"e^f": 3,
"g|h": 4,
"i\\j": 5,
"k\"l": 6,
" ": 7,
"m~n": 8
}"#;
assert_eq!(get(doc, ""), Some(doc.trim()));
assert_eq!(get(doc, "/foo"), Some(r#"["bar", "baz"]"#));
assert_eq!(get(doc, "/foo/0"), Some("\"bar\""));
assert_eq!(get(doc, "/"), Some("0"));
assert_eq!(get(doc, "/a~1b"), Some("1"));
assert_eq!(get(doc, "/c%d"), Some("2"));
assert_eq!(get(doc, "/e^f"), Some("3"));
assert_eq!(get(doc, "/g|h"), Some("4"));
assert_eq!(get(doc, "/i\\j"), Some("5"));
assert_eq!(get(doc, "/k\"l"), Some("6"));
assert_eq!(get(doc, "/ "), Some("7"));
assert_eq!(get(doc, "/m~0n"), Some("8"));
}
#[test]
fn misses_are_none() {
let doc = r#"{"a":[10,20],"b":{"c":true}}"#;
assert_eq!(get(doc, "/missing"), None);
assert_eq!(get(doc, "/a/2"), None); assert_eq!(get(doc, "/a/-"), None); assert_eq!(get(doc, "/a/01"), None); assert_eq!(get(doc, "/a/x"), None); assert_eq!(get(doc, "/a/0/deeper"), None); assert_eq!(get(doc, "/b/c/d"), None);
assert_eq!(get("[]", "/0"), None); }
#[test]
fn nested_and_escaped() {
let doc = r#"{"a":{"b":[{"deep":[1,{"x":"found"}]}]},"z":9}"#;
assert_eq!(get(doc, "/a/b/0/deep/1/x"), Some("\"found\""));
assert_eq!(get(doc, "/z"), Some("9"));
let doc = r#"{"k\ney": 42}"#;
assert_eq!(get(doc, "/k\ney"), Some("42"));
let doc = r#"{"d":1,"d":2}"#;
assert_eq!(get(doc, "/d"), Some("1"));
let doc = r#"{"skip":["}{][", "a\"b", {"x":"]"}],"hit":1}"#;
assert_eq!(get(doc, "/hit"), Some("1"));
}
#[test]
fn errors() {
let mut bufs = Buffers::new();
assert_eq!(
pointer("{}", "no-slash", &mut bufs).unwrap_err().kind,
ErrorKind::InvalidPointer
);
assert!(pointer("{\"a\":", "/a", &mut bufs).is_err());
assert!(pointer("[1,2", "/5", &mut bufs).is_err());
}
#[test]
fn batch_matches_sequential() {
let doc = r#"{
"users": [{"name":"ada","tags":[1,2]},{"name":"grace"}],
"a/b": 5, "m~n": {"deep": true}, "empty": {}, "arr": []
}"#;
let ptrs = [
"/users/1/name",
"/users/0/tags/1",
"/users/0/name",
"/missing",
"/users/5",
"/a~1b",
"/m~0n/deep",
"/empty/x",
"/arr/0",
"/users/0/tags",
"",
];
let mut bufs = Buffers::new();
let batch = pointers(doc, &ptrs, &mut bufs).unwrap();
for (ptr, got) in ptrs.iter().zip(&batch) {
let single = pointer(doc, ptr, &mut bufs).unwrap();
assert_eq!(*got, single, "pointer {ptr:?}");
}
let batch = pointers(doc, &["/a~1b", "/a~1b"], &mut bufs).unwrap();
assert_eq!(batch, [Some("5"), Some("5")]);
assert_eq!(
pointers(doc, &[], &mut bufs).unwrap(),
Vec::<Option<&str>>::new()
);
assert!(pointers(doc, &["/ok", "bad"], &mut bufs).is_err());
}
#[test]
fn batch_duplicate_keys_first_match_wins() {
let mut bufs = Buffers::new();
let doc = r#"{"a":8,"a":{"b":9}}"#;
assert_eq!(pointer(doc, "/a/b", &mut bufs), Ok(None));
assert_eq!(
pointers(doc, &["/a/b", "/a"], &mut bufs).unwrap(),
[None, Some("8")]
);
}
#[test]
fn batch_validates_what_it_scans() {
let mut bufs = Buffers::new();
assert_eq!(pointer("-", "/", &mut bufs), Ok(None));
assert!(pointers("-", &["/"], &mut bufs).is_err());
}
#[test]
fn slice_reparses() {
let doc = r#"{"list":[{"n":1.5},{"n":"two"},{"n":[3]}]}"#;
for (ptr, expected) in [
("/list/0", r#"{"n":1.5}"#),
("/list/1/n", "\"two\""),
("/list/2/n", "[3]"),
] {
let raw = get(doc, ptr).unwrap();
assert_eq!(raw, expected);
let mut bufs = Buffers::new();
let mut p = crate::Reader::new(raw, &mut bufs);
p.skip_value().unwrap();
p.finish().unwrap();
}
}
}