use std::borrow::Cow;
use crate::error::Error;
use crate::path::PathSegment;
use crate::scan::{find_string_end, find_value, skip_value, skip_whitespace};
use crate::view::JsonView;
#[inline]
pub fn read_external_unit<T, F>(json: &[u8], mut match_name: F) -> Result<T, Error>
where
F: FnMut(&str) -> Option<T>,
{
let start = skip_whitespace(json, 0);
if start >= json.len() || json[start] != b'"' {
return Err(Error::TypeMismatch {
expected: "string (unit enum)",
found: type_hint(json, start),
});
}
let content_start = start + 1;
let end_q = find_string_end(json, content_start)?;
let raw = &json[content_start..end_q];
let after = end_q + 1;
ensure_only_trailing_ws(json, after)?;
if !raw.contains(&b'\\') {
let name = std::str::from_utf8(raw).map_err(|_| Error::TypeMismatch {
expected: "utf-8 string",
found: "invalid utf-8",
})?;
return match_name(name).ok_or_else(|| Error::Decode {
path: name.to_string(),
expected: "known unit variant",
found: "unknown variant",
pos: Some(start),
});
}
let lit = &json[start..=end_q];
let s = crate::convert::from_json_string(lit).ok_or(Error::TypeMismatch {
expected: "string",
found: "invalid escape",
})?;
match_name(&s).ok_or(Error::Decode {
path: s,
expected: "known unit variant",
found: "unknown variant",
pos: Some(start),
})
}
#[inline]
pub fn peek_external_object(json: &[u8]) -> Result<ExternalTag<'_>, Error> {
let start = skip_whitespace(json, 0);
if start >= json.len() || json[start] != b'{' {
return Err(Error::TypeMismatch {
expected: "object (externally tagged enum)",
found: type_hint(json, start),
});
}
let mut pos = skip_whitespace(json, start + 1);
if pos >= json.len() || json[pos] == b'}' {
return Err(Error::Decode {
path: String::new(),
expected: "one variant key",
found: "empty object",
pos: Some(pos),
});
}
if json[pos] != b'"' {
return Err(Error::InvalidJsonSyntax {
pos,
msg: "Expected variant tag string",
});
}
let ks = pos + 1;
let ke = find_string_end(json, ks)?;
let tag_raw = &json[ks..ke];
pos = skip_whitespace(json, ke + 1);
if pos >= json.len() || json[pos] != b':' {
return Err(Error::InvalidJsonSyntax {
pos,
msg: "Expected colon after enum tag",
});
}
pos = skip_whitespace(json, pos + 1);
let vs = pos;
let ve = skip_value(json, vs)?;
let payload = &json[vs..ve];
pos = skip_whitespace(json, ve);
if pos < json.len() && json[pos] == b',' {
return Err(Error::Decode {
path: String::new(),
expected: "single-key external tag object",
found: "multiple keys",
pos: Some(pos),
});
}
if pos >= json.len() || json[pos] != b'}' {
return Err(Error::InvalidJsonSyntax {
pos,
msg: "Expected closing brace after enum payload",
});
}
ensure_only_trailing_ws(json, pos + 1)?;
Ok(ExternalTag { tag_raw, payload })
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ExternalTag<'a> {
pub tag_raw: &'a [u8],
pub payload: &'a [u8],
}
impl<'a> ExternalTag<'a> {
#[inline]
pub fn tag_str(&self) -> Result<&'a str, Error> {
if self.tag_raw.contains(&b'\\') {
return Err(Error::TypeMismatch {
expected: "unescaped variant tag",
found: "escaped tag",
});
}
std::str::from_utf8(self.tag_raw).map_err(|_| Error::TypeMismatch {
expected: "utf-8 tag",
found: "invalid utf-8",
})
}
#[inline]
pub fn tag_cow(&self) -> Result<Cow<'a, str>, Error> {
if !self.tag_raw.contains(&b'\\') {
let s = std::str::from_utf8(self.tag_raw).map_err(|_| Error::TypeMismatch {
expected: "utf-8 tag",
found: "invalid utf-8",
})?;
return Ok(Cow::Borrowed(s));
}
let mut lit = Vec::with_capacity(self.tag_raw.len() + 2);
lit.push(b'"');
lit.extend_from_slice(self.tag_raw);
lit.push(b'"');
let s = crate::convert::from_json_string(&lit).ok_or(Error::TypeMismatch {
expected: "string tag",
found: "invalid escape",
})?;
Ok(Cow::Owned(s))
}
}
#[inline]
pub fn read_external_object<T, F>(json: &[u8], mut decode: F) -> Result<T, Error>
where
F: FnMut(&str, &[u8]) -> Result<T, Error>,
{
let tag = peek_external_object(json)?;
let name = tag.tag_cow()?;
decode(name.as_ref(), tag.payload)
}
#[inline]
pub fn read_external<T, FU, FO>(
json: &[u8],
on_unit: FU,
on_object: FO,
) -> Result<T, Error>
where
FU: FnMut(&str) -> Option<T>,
FO: FnMut(&str, &[u8]) -> Result<T, Error>,
{
let start = skip_whitespace(json, 0);
if start >= json.len() {
return Err(Error::TypeMismatch {
expected: "string or object (external enum)",
found: "eof",
});
}
match json[start] {
b'"' => read_external_unit(json, on_unit),
b'{' => read_external_object(json, on_object),
_ => Err(Error::TypeMismatch {
expected: "string or object (external enum)",
found: type_hint(json, start),
}),
}
}
#[inline]
pub fn write_external_unit(out: &mut Vec<u8>, variant: &str) {
crate::convert::write_json_string(out, variant);
}
#[inline]
pub fn write_external_object(out: &mut Vec<u8>, variant: &str, payload_json: &[u8]) {
out.reserve(variant.len().saturating_add(payload_json.len()).saturating_add(8));
out.push(b'{');
crate::convert::write_json_string(out, variant);
out.push(b':');
out.extend_from_slice(payload_json);
out.push(b'}');
}
#[inline]
pub fn payload_as_view<V: JsonView>(payload: &[u8]) -> Result<V, Error> {
V::read_from(payload)
}
#[inline]
pub fn is_external_unit_shape(json: &[u8]) -> bool {
let p = skip_whitespace(json, 0);
p < json.len() && json[p] == b'"'
}
#[inline]
pub fn is_external_object_shape(json: &[u8]) -> bool {
let p = skip_whitespace(json, 0);
p < json.len() && json[p] == b'{'
}
#[inline]
pub fn read_tag_field<'a>(json: &'a [u8], tag_key: &str) -> Result<Cow<'a, str>, Error> {
ensure_object_root(json)?;
let path = [PathSegment::Key(tag_key)];
let slice = find_value(json, &path).map_err(|e| match e {
Error::PathNotFound => Error::Decode {
path: tag_key.to_string(),
expected: "tag field present",
found: "missing tag key",
pos: None,
},
other => other,
})?;
decode_json_string_cow(slice)
}
#[inline]
pub fn read_internal<T, F>(json: &[u8], tag_key: &str, mut decode: F) -> Result<T, Error>
where
F: FnMut(&str, &[u8]) -> Result<T, Error>,
{
let name = read_tag_field(json, tag_key)?;
let start = skip_whitespace(json, 0);
let end = skip_value(json, start)?;
ensure_only_trailing_ws(json, end)?;
decode(name.as_ref(), &json[start..end])
}
#[inline]
pub fn write_internal_unit(out: &mut Vec<u8>, tag_key: &str, variant: &str) {
out.reserve(tag_key.len() + variant.len() + 16);
out.push(b'{');
crate::convert::write_json_string(out, tag_key);
out.push(b':');
crate::convert::write_json_string(out, variant);
out.push(b'}');
}
#[inline]
pub fn write_internal_fields(
out: &mut Vec<u8>,
tag_key: &str,
variant: &str,
fields_object: &[u8],
) {
let fo = trim_ws(fields_object);
assert_object_bytes(fo);
out.reserve(tag_key.len() + variant.len() + fo.len() + 16);
out.push(b'{');
crate::convert::write_json_string(out, tag_key);
out.push(b':');
crate::convert::write_json_string(out, variant);
let inner = object_inner(fo);
if !inner.is_empty() {
out.push(b',');
out.extend_from_slice(inner);
}
out.push(b'}');
}
#[inline]
pub fn read_adjacent<T, F>(
json: &[u8],
tag_key: &str,
content_key: &str,
mut decode: F,
) -> Result<T, Error>
where
F: FnMut(&str, Option<&[u8]>) -> Result<T, Error>,
{
ensure_object_root(json)?;
let name = read_tag_field(json, tag_key)?;
let cpath = [PathSegment::Key(content_key)];
let content = match find_value(json, &cpath) {
Ok(slice) => {
let t = trim_ws(slice);
if t == b"null" {
None
} else {
Some(slice)
}
}
Err(Error::PathNotFound) => None,
Err(e) => return Err(e),
};
let start = skip_whitespace(json, 0);
let end = skip_value(json, start)?;
ensure_only_trailing_ws(json, end)?;
decode(name.as_ref(), content)
}
#[inline]
pub fn write_adjacent_unit(out: &mut Vec<u8>, tag_key: &str, variant: &str) {
write_internal_unit(out, tag_key, variant);
}
#[inline]
pub fn write_adjacent_content(
out: &mut Vec<u8>,
tag_key: &str,
variant: &str,
content_key: &str,
payload_json: &[u8],
) {
out.reserve(tag_key.len() + content_key.len() + variant.len() + payload_json.len() + 24);
out.push(b'{');
crate::convert::write_json_string(out, tag_key);
out.push(b':');
crate::convert::write_json_string(out, variant);
out.push(b',');
crate::convert::write_json_string(out, content_key);
out.push(b':');
out.extend_from_slice(payload_json);
out.push(b'}');
}
pub fn read_untagged<T, I, F>(json: &[u8], decoders: I) -> Result<T, Error>
where
I: IntoIterator<Item = F>,
F: FnOnce(&[u8]) -> Result<T, Error>,
{
let mut last = Error::Decode {
path: String::new(),
expected: "matching untagged variant",
found: "no decoder succeeded",
pos: None,
};
let mut any = false;
for dec in decoders {
any = true;
match dec(json) {
Ok(v) => return Ok(v),
Err(e) => last = e,
}
}
if !any {
return Err(Error::Decode {
path: String::new(),
expected: "at least one untagged decoder",
found: "empty decoder list",
pos: None,
});
}
Err(last)
}
#[inline]
fn ensure_object_root(json: &[u8]) -> Result<(), Error> {
let p = skip_whitespace(json, 0);
if p >= json.len() || json[p] != b'{' {
return Err(Error::TypeMismatch {
expected: "object (tagged enum)",
found: type_hint(json, p),
});
}
Ok(())
}
#[inline]
fn trim_ws(json: &[u8]) -> &[u8] {
let mut s = 0;
let mut e = json.len();
while s < e && matches!(json[s], b' ' | b'\t' | b'\n' | b'\r') {
s += 1;
}
while e > s && matches!(json[e - 1], b' ' | b'\t' | b'\n' | b'\r') {
e -= 1;
}
&json[s..e]
}
#[inline]
fn assert_object_bytes(fo: &[u8]) {
debug_assert!(fo.first() == Some(&b'{') && fo.last() == Some(&b'}'));
}
#[inline]
fn object_inner(fo: &[u8]) -> &[u8] {
let fo = trim_ws(fo);
if fo.len() >= 2 && fo[0] == b'{' && fo[fo.len() - 1] == b'}' {
trim_ws(&fo[1..fo.len() - 1])
} else {
fo
}
}
fn decode_json_string_cow<'a>(slice: &'a [u8]) -> Result<Cow<'a, str>, Error> {
let t = trim_ws(slice);
if t.len() < 2 || t[0] != b'"' || t[t.len() - 1] != b'"' {
return Err(Error::TypeMismatch {
expected: "string (enum tag)",
found: type_hint(t, 0),
});
}
let raw = &t[1..t.len() - 1];
if !raw.contains(&b'\\') {
let s = std::str::from_utf8(raw).map_err(|_| Error::TypeMismatch {
expected: "utf-8 tag",
found: "invalid utf-8",
})?;
return Ok(Cow::Borrowed(s));
}
let s = crate::convert::from_json_string(t).ok_or(Error::TypeMismatch {
expected: "string tag",
found: "invalid escape",
})?;
Ok(Cow::Owned(s))
}
#[inline]
fn ensure_only_trailing_ws(json: &[u8], pos: usize) -> Result<(), Error> {
let pos = skip_whitespace(json, pos);
if pos < json.len() {
return Err(Error::InvalidJsonSyntax {
pos,
msg: "Trailing data after enum value",
});
}
Ok(())
}
#[inline]
fn type_hint(json: &[u8], pos: usize) -> &'static str {
if pos >= json.len() {
return "eof";
}
match json[pos] {
b'{' => "object",
b'[' => "array",
b'"' => "string",
b't' | b'f' => "bool",
b'n' => "null",
b'-' | b'0'..=b'9' => "number",
_ => "invalid",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{find_value, parse_path, FromJsonSlice, ToJsonBytes};
#[test]
fn unit_and_object_tags() {
let u = read_external_unit(br#""Ready""#, |s| match s {
"Ready" => Some(1u8),
"Done" => Some(2),
_ => None,
})
.unwrap();
assert_eq!(u, 1);
let tag = peek_external_object(br#"{"Click":{"x":1,"y":2}}"#).unwrap();
assert_eq!(tag.tag_str().unwrap(), "Click");
assert_eq!(
u64::from_json_slice(find_value(tag.payload, &parse_path("x")).unwrap()).unwrap(),
1
);
let mut out = Vec::new();
write_external_object(&mut out, "Id", &7u64.to_json_bytes());
assert_eq!(out, br#"{"Id":7}"#);
}
#[test]
fn unit_zero_copy_and_ws() {
let json = br#" "Ready" "#;
let name_ptr = read_external_unit(json, |s| {
assert_eq!(s, "Ready");
Some(s.as_ptr() as usize)
})
.unwrap();
assert!(name_ptr >= json.as_ptr() as usize);
assert!(name_ptr < json.as_ptr() as usize + json.len());
}
#[test]
fn rejects_trailing_junk() {
assert!(read_external_unit(br#""Ready"0"#, |_| Some(1u8)).is_err());
assert!(peek_external_object(br#"{"A":1}0"#).is_err());
}
#[test]
fn rejects_multi_key_and_empty() {
assert!(peek_external_object(br#"{"A":1,"B":2}"#).is_err());
assert!(peek_external_object(br#"{}"#).is_err());
}
#[test]
fn object_tag_zero_alloc_unescaped() {
let json = br#"{"Click":{"x":1}}"#;
read_external_object(json, |name, payload| {
assert_eq!(name, "Click");
assert_eq!(
name.as_ptr() as usize,
json.as_ptr() as usize + 2 );
assert!(payload.starts_with(b"{"));
Ok(())
})
.unwrap();
}
#[test]
fn mixed_read_external() {
#[derive(Debug, PartialEq)]
enum E {
None,
Id(u64),
}
let n = read_external(
br#""None""#,
|s| match s {
"None" => Some(E::None),
_ => None,
},
|name, payload| match name {
"Id" => Ok(E::Id(u64::from_json_slice(payload).unwrap())),
_ => Err(Error::PathNotFound),
},
)
.unwrap();
assert_eq!(n, E::None);
let i = read_external(
br#"{"Id":9}"#,
|_| None,
|name, payload| match name {
"Id" => Ok(E::Id(u64::from_json_slice(payload).unwrap())),
_ => Err(Error::PathNotFound),
},
)
.unwrap();
assert_eq!(i, E::Id(9));
}
#[test]
fn escaped_unit_tag() {
let v = read_external_unit(br#""say \"hi\"""#, |s| {
if s == "say \"hi\"" {
Some(1u8)
} else {
None
}
})
.unwrap();
assert_eq!(v, 1);
}
#[test]
fn internal_unit_and_struct() {
#[derive(Debug, PartialEq)]
enum Ev {
Ready,
Click { x: u64, y: u64 },
}
let u = read_internal(br#"{"type":"Ready"}"#, "type", |name, _| match name {
"Ready" => Ok(Ev::Ready),
_ => Err(Error::PathNotFound),
})
.unwrap();
assert_eq!(u, Ev::Ready);
let c = read_internal(
br#"{"type":"Click","x":3,"y":4}"#,
"type",
|name, obj| match name {
"Click" => Ok(Ev::Click {
x: u64::from_json_slice(find_value(obj, &parse_path("x")).unwrap()).unwrap(),
y: u64::from_json_slice(find_value(obj, &parse_path("y")).unwrap()).unwrap(),
}),
_ => Err(Error::PathNotFound),
},
)
.unwrap();
assert_eq!(c, Ev::Click { x: 3, y: 4 });
let mut out = Vec::new();
write_internal_unit(&mut out, "type", "Ready");
assert_eq!(out, br#"{"type":"Ready"}"#);
let mut out = Vec::new();
write_internal_fields(&mut out, "type", "Click", br#"{"x":3,"y":4}"#);
assert_eq!(out, br#"{"type":"Click","x":3,"y":4}"#);
}
#[test]
fn adjacent_unit_and_content() {
#[derive(Debug, PartialEq)]
enum Ev {
Ready,
Id(u64),
}
let u = read_adjacent(br#"{"t":"Ready"}"#, "t", "c", |name, c| match (name, c) {
("Ready", None) => Ok(Ev::Ready),
_ => Err(Error::PathNotFound),
})
.unwrap();
assert_eq!(u, Ev::Ready);
let i = read_adjacent(br#"{"t":"Id","c":9}"#, "t", "c", |name, c| match (name, c) {
("Id", Some(p)) => Ok(Ev::Id(u64::from_json_slice(p).unwrap())),
_ => Err(Error::PathNotFound),
})
.unwrap();
assert_eq!(i, Ev::Id(9));
let mut out = Vec::new();
write_adjacent_content(&mut out, "t", "Id", "c", b"9");
assert_eq!(out, br#"{"t":"Id","c":9}"#);
}
#[test]
fn untagged_number_then_string() {
#[derive(Debug, PartialEq)]
enum Val {
N(u64),
S(String),
}
let n = read_untagged(
br#"42"#,
[
|j: &[u8]| {
Ok(Val::N(
u64::from_json_slice(j).ok_or(Error::PathNotFound)?,
))
},
|j: &[u8]| {
Ok(Val::S(
String::from_json_slice(j).ok_or(Error::PathNotFound)?,
))
},
],
)
.unwrap();
assert_eq!(n, Val::N(42));
let s = read_untagged(
br#""hi""#,
[
|j: &[u8]| {
Ok(Val::N(
u64::from_json_slice(j).ok_or(Error::PathNotFound)?,
))
},
|j: &[u8]| {
Ok(Val::S(
String::from_json_slice(j).ok_or(Error::PathNotFound)?,
))
},
],
)
.unwrap();
assert_eq!(s, Val::S("hi".into()));
}
}