use std::marker::PhantomData;
use crate::convert::FromJsonSlice;
use crate::error::Error;
use crate::path::{try_parse_path, PathSegment};
use crate::scan::{find_value_offsets, skip_value, skip_whitespace};
use crate::typed_doc::{ArrayElems, JsonDoc};
use crate::view::JsonView;
#[derive(Clone, Copy, Debug)]
struct ArraySpan<'a> {
bytes: &'a [u8],
}
impl<'a> ArraySpan<'a> {
fn from_bytes(bytes: &'a [u8]) -> Result<Self, Error> {
let start = skip_whitespace(bytes, 0);
if start >= bytes.len() || bytes[start] != b'[' {
return Err(Error::TypeMismatch {
expected: "array",
found: "primitive/object",
});
}
let end = skip_value(bytes, start)?;
if end == 0 || bytes[end - 1] != b']' {
return Err(Error::InvalidJsonSyntax {
pos: end.saturating_sub(1),
msg: "Expected array",
});
}
Ok(Self {
bytes: &bytes[start..end],
})
}
fn from_doc_path(json: &'a [u8], path: &[PathSegment]) -> Result<Self, Error> {
let (start, end) = find_value_offsets(json, path)?;
if start >= json.len() || json[start] != b'[' {
return Err(Error::TypeMismatch {
expected: "array",
found: "primitive/object",
});
}
Ok(Self {
bytes: &json[start..end],
})
}
fn elems(&self) -> ArrayElems<'a> {
ArrayElems::open_span(self.bytes)
}
fn len(&self) -> Result<usize, Error> {
let mut n = 0usize;
for item in self.elems() {
item?;
n = n.checked_add(1).ok_or(Error::InvalidJsonSyntax {
pos: 0,
msg: "Array length overflow",
})?;
}
Ok(n)
}
fn get_raw(&self, index: usize) -> Result<&'a [u8], Error> {
for (i, item) in self.elems().enumerate() {
let item = item?;
if i == index {
return Ok(item);
}
}
Err(Error::IndexOutOfBounds { index })
}
fn index_elems(&self) -> Result<Vec<&'a [u8]>, Error> {
let mut out = Vec::new();
for item in self.elems() {
out.push(item?);
}
Ok(out)
}
}
#[derive(Clone, Copy, Debug)]
pub struct ViewList<'a, T: JsonView> {
span: ArraySpan<'a>,
_marker: PhantomData<T>,
}
impl<'a, T: JsonView> ViewList<'a, T> {
pub fn from_array_bytes(bytes: &'a [u8]) -> Result<Self, Error> {
Ok(Self {
span: ArraySpan::from_bytes(bytes)?,
_marker: PhantomData,
})
}
pub fn from_doc(doc: &'a impl JsonDoc, path: &str) -> Result<Self, Error> {
let segs = try_parse_path(path)?;
Ok(Self {
span: ArraySpan::from_doc_path(doc.as_json_bytes(), &segs)?,
_marker: PhantomData,
})
}
#[inline]
pub fn as_bytes(&self) -> &'a [u8] {
self.span.bytes
}
#[inline]
pub fn len(&self) -> Result<usize, Error> {
self.span.len()
}
pub fn is_empty(&self) -> Result<bool, Error> {
Ok(self.len()? == 0)
}
pub fn get(&self, index: usize) -> Result<T, Error> {
let raw = self.span.get_raw(index)?;
T::read_from(raw)
}
pub fn get_raw(&self, index: usize) -> Result<&'a [u8], Error> {
self.span.get_raw(index)
}
pub fn iter(&self) -> ViewListIter<'a, T> {
ViewListIter {
elems: self.span.elems(),
_marker: PhantomData,
}
}
pub fn each<F>(&self, mut f: F) -> Result<(), Error>
where
F: FnMut(T) -> Result<(), Error>,
{
for item in self.iter() {
f(item?)?;
}
Ok(())
}
pub fn collect_owned(&self) -> Result<Vec<T>, Error> {
let mut out = Vec::new();
self.each(|v| {
out.push(v);
Ok(())
})?;
Ok(out)
}
#[inline]
pub fn raw_elems(&self) -> ArrayElems<'a> {
self.span.elems()
}
pub fn index(&self) -> Result<IndexedViewList<'a, T>, Error> {
Ok(IndexedViewList {
elems: self.span.index_elems()?,
_marker: PhantomData,
})
}
}
#[derive(Clone, Debug)]
pub struct IndexedViewList<'a, T: JsonView> {
elems: Vec<&'a [u8]>,
_marker: PhantomData<T>,
}
impl<'a, T: JsonView> IndexedViewList<'a, T> {
#[inline]
pub fn len(&self) -> usize {
self.elems.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.elems.is_empty()
}
#[inline]
pub fn get_raw(&self, index: usize) -> Result<&'a [u8], Error> {
self.elems
.get(index)
.copied()
.ok_or(Error::IndexOutOfBounds { index })
}
#[inline]
pub fn get(&self, index: usize) -> Result<T, Error> {
T::read_from(self.get_raw(index)?)
}
#[inline]
pub fn as_slices(&self) -> &[&'a [u8]] {
&self.elems
}
pub fn iter(&self) -> impl Iterator<Item = Result<T, Error>> + '_ {
self.elems.iter().map(|raw| T::read_from(raw))
}
pub fn each<F>(&self, mut f: F) -> Result<(), Error>
where
F: FnMut(T) -> Result<(), Error>,
{
for raw in &self.elems {
f(T::read_from(raw)?)?;
}
Ok(())
}
pub fn collect_owned(&self) -> Result<Vec<T>, Error> {
let mut out = Vec::with_capacity(self.elems.len());
self.each(|v| {
out.push(v);
Ok(())
})?;
Ok(out)
}
}
pub struct ViewListIter<'a, T: JsonView> {
elems: ArrayElems<'a>,
_marker: PhantomData<T>,
}
impl<'a, T: JsonView> Iterator for ViewListIter<'a, T> {
type Item = Result<T, Error>;
fn next(&mut self) -> Option<Self::Item> {
match self.elems.next()? {
Ok(raw) => Some(T::read_from(raw)),
Err(e) => Some(Err(e)),
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct ValueList<'a, T: FromJsonSlice> {
span: ArraySpan<'a>,
_marker: PhantomData<T>,
}
impl<'a, T: FromJsonSlice> ValueList<'a, T> {
pub fn from_array_bytes(bytes: &'a [u8]) -> Result<Self, Error> {
Ok(Self {
span: ArraySpan::from_bytes(bytes)?,
_marker: PhantomData,
})
}
pub fn from_doc(doc: &'a impl JsonDoc, path: &str) -> Result<Self, Error> {
let segs = try_parse_path(path)?;
Ok(Self {
span: ArraySpan::from_doc_path(doc.as_json_bytes(), &segs)?,
_marker: PhantomData,
})
}
#[inline]
pub fn as_bytes(&self) -> &'a [u8] {
self.span.bytes
}
#[inline]
pub fn len(&self) -> Result<usize, Error> {
self.span.len()
}
pub fn is_empty(&self) -> Result<bool, Error> {
Ok(self.len()? == 0)
}
pub fn get(&self, index: usize) -> Result<T, Error> {
let raw = self.span.get_raw(index)?;
T::from_json_slice(raw).ok_or(Error::TypeMismatch {
expected: std::any::type_name::<T>(),
found: "invalid format",
})
}
pub fn get_raw(&self, index: usize) -> Result<&'a [u8], Error> {
self.span.get_raw(index)
}
pub fn iter(&self) -> ValueListIter<'a, T> {
ValueListIter {
elems: self.span.elems(),
_marker: PhantomData,
}
}
pub fn each<F>(&self, mut f: F) -> Result<(), Error>
where
F: FnMut(T) -> Result<(), Error>,
{
for item in self.iter() {
f(item?)?;
}
Ok(())
}
pub fn collect_owned(&self) -> Result<Vec<T>, Error> {
let mut out = Vec::new();
self.each(|v| {
out.push(v);
Ok(())
})?;
Ok(out)
}
pub fn index(&self) -> Result<IndexedValueList<'a, T>, Error> {
Ok(IndexedValueList {
elems: self.span.index_elems()?,
_marker: PhantomData,
})
}
}
#[derive(Clone, Debug)]
pub struct IndexedValueList<'a, T: FromJsonSlice> {
elems: Vec<&'a [u8]>,
_marker: PhantomData<T>,
}
impl<'a, T: FromJsonSlice> IndexedValueList<'a, T> {
#[inline]
pub fn len(&self) -> usize {
self.elems.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.elems.is_empty()
}
#[inline]
pub fn get_raw(&self, index: usize) -> Result<&'a [u8], Error> {
self.elems
.get(index)
.copied()
.ok_or(Error::IndexOutOfBounds { index })
}
#[inline]
pub fn get(&self, index: usize) -> Result<T, Error> {
let raw = self.get_raw(index)?;
T::from_json_slice(raw).ok_or(Error::TypeMismatch {
expected: std::any::type_name::<T>(),
found: "invalid format",
})
}
#[inline]
pub fn as_slices(&self) -> &[&'a [u8]] {
&self.elems
}
pub fn collect_owned(&self) -> Result<Vec<T>, Error> {
let mut out = Vec::with_capacity(self.elems.len());
for raw in &self.elems {
out.push(T::from_json_slice(raw).ok_or(Error::TypeMismatch {
expected: std::any::type_name::<T>(),
found: "invalid format",
})?);
}
Ok(out)
}
}
pub struct ValueListIter<'a, T: FromJsonSlice> {
elems: ArrayElems<'a>,
_marker: PhantomData<T>,
}
impl<'a, T: FromJsonSlice> Iterator for ValueListIter<'a, T> {
type Item = Result<T, Error>;
fn next(&mut self) -> Option<Self::Item> {
match self.elems.next()? {
Ok(raw) => Some(
T::from_json_slice(raw).ok_or(Error::TypeMismatch {
expected: std::any::type_name::<T>(),
found: "invalid format",
}),
),
Err(e) => Some(Err(e)),
}
}
}
use crate::typed_doc::{TypedDoc, TypedDocRef};
impl TypedDoc {
#[inline]
pub fn view_list<T: JsonView>(&self, path: &str) -> Result<ViewList<'_, T>, Error> {
ViewList::from_doc(self, path)
}
#[inline]
pub fn value_list<T: FromJsonSlice>(&self, path: &str) -> Result<ValueList<'_, T>, Error> {
ValueList::from_doc(self, path)
}
#[inline]
pub fn root_view_list<T: JsonView>(&self) -> Result<ViewList<'_, T>, Error> {
ViewList::from_array_bytes(self.as_bytes())
}
#[inline]
pub fn root_value_list<T: FromJsonSlice>(&self) -> Result<ValueList<'_, T>, Error> {
ValueList::from_array_bytes(self.as_bytes())
}
}
impl TypedDocRef<'_> {
#[inline]
pub fn view_list<T: JsonView>(&self, path: &str) -> Result<ViewList<'_, T>, Error> {
ViewList::from_doc(self, path)
}
#[inline]
pub fn value_list<T: FromJsonSlice>(&self, path: &str) -> Result<ValueList<'_, T>, Error> {
ValueList::from_doc(self, path)
}
#[inline]
pub fn root_view_list<T: JsonView>(&self) -> Result<ViewList<'_, T>, Error> {
ViewList::from_array_bytes(self.as_bytes())
}
#[inline]
pub fn root_value_list<T: FromJsonSlice>(&self) -> Result<ValueList<'_, T>, Error> {
ValueList::from_array_bytes(self.as_bytes())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::convert::ToJsonBytes;
use crate::path::parse_path;
use crate::scan::find_value;
use crate::typed_doc::TypedDoc;
use crate::upsert_at_path;
struct Card {
id: u64,
}
impl JsonView for Card {
fn read_from(json: &[u8]) -> Result<Self, Error> {
let s = find_value(json, &parse_path("id"))?;
Ok(Self {
id: u64::from_json_slice(s).ok_or(Error::TypeMismatch {
expected: "u64",
found: "bad",
})?,
})
}
fn write_into(&self, json: &mut Vec<u8>) -> Result<(), Error> {
upsert_at_path(json, &parse_path("id"), &self.id.to_json_bytes())
}
}
#[test]
fn view_list_get_iter_collect() {
let doc = TypedDoc::from_slice(br#"{"items":[{"id":1},{"id":2},{"id":3}]}"#);
let list = ViewList::<Card>::from_doc(&doc, "items").unwrap();
assert_eq!(list.len().unwrap(), 3);
assert_eq!(list.get(0).unwrap().id, 1);
assert_eq!(list.get(2).unwrap().id, 3);
let ids: Vec<_> = list.iter().map(|r| r.unwrap().id).collect();
assert_eq!(ids, vec![1, 2, 3]);
assert_eq!(list.collect_owned().unwrap().len(), 3);
}
#[test]
fn value_list_primitives() {
let doc = TypedDoc::from_slice(br#"[10,20,30]"#);
let list = ValueList::<u64>::from_array_bytes(doc.as_bytes()).unwrap();
assert_eq!(list.collect_owned().unwrap(), vec![10, 20, 30]);
assert_eq!(list.get(1).unwrap(), 20);
}
#[test]
fn root_array_view_list() {
let json = br#"[{"id":9}]"#;
let list = ViewList::<Card>::from_array_bytes(json).unwrap();
assert_eq!(list.get(0).unwrap().id, 9);
}
#[test]
fn indexed_view_list_o1_get() {
let doc = TypedDoc::from_slice(br#"{"items":[{"id":0},{"id":1},{"id":2},{"id":3}]}"#);
let idx = doc.view_list::<Card>("items").unwrap().index().unwrap();
assert_eq!(idx.len(), 4);
assert_eq!(idx.get(3).unwrap().id, 3);
assert_eq!(idx.get(0).unwrap().id, 0);
assert!(matches!(
idx.get(99),
Err(Error::IndexOutOfBounds { index: 99 })
));
}
#[test]
fn indexed_value_list() {
let list = ValueList::<u64>::from_array_bytes(br#"[5,6,7]"#)
.unwrap()
.index()
.unwrap();
assert_eq!(list.get(1).unwrap(), 6);
assert_eq!(list.collect_owned().unwrap(), vec![5, 6, 7]);
}
}