use crate::error::Error;
use crate::view::JsonView;
use crate::view_list::ViewList;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum CollectPolicy {
#[default]
Stream,
Owned,
Projected,
}
#[derive(Debug, Clone)]
pub enum Collected<T> {
Stream,
Owned(Vec<T>),
Projected(Vec<Vec<u8>>),
}
impl<'a, T: JsonView> ViewList<'a, T> {
pub fn collect(&self, policy: CollectPolicy) -> Result<Collected<T>, Error> {
match policy {
CollectPolicy::Stream => Ok(Collected::Stream),
CollectPolicy::Owned => Ok(Collected::Owned(self.collect_owned()?)),
CollectPolicy::Projected => Ok(Collected::Projected(self.collect_projected()?)),
}
}
pub fn collect_projected(&self) -> Result<Vec<Vec<u8>>, Error> {
let mut out = Vec::new();
self.for_each_raw(|raw| {
out.push(T::project_bytes(raw)?);
Ok(())
})?;
Ok(out)
}
pub fn each_filtered<F, P>(&self, mut pred: P, mut f: F) -> Result<(), Error>
where
P: FnMut(&T) -> bool,
F: FnMut(T) -> Result<(), Error>,
{
self.each(|item| {
if pred(&item) {
f(item)?;
}
Ok(())
})
}
pub fn each_field<U, F>(&self, field_path: &str, mut f: F) -> Result<(), Error>
where
U: crate::convert::FromJsonSlice,
F: FnMut(U) -> Result<(), Error>,
{
let field = crate::path::try_parse_path(field_path)?;
self.for_each_raw(|raw| {
let slice = crate::scan::find_value(raw, &field)?;
let v = U::from_json_slice(slice).ok_or(Error::TypeMismatch {
expected: std::any::type_name::<U>(),
found: "invalid format",
})?;
f(v)
})
}
pub fn collect_field<U: crate::convert::FromJsonSlice>(
&self,
field_path: &str,
) -> Result<Vec<U>, Error> {
let mut out = Vec::new();
self.each_field(field_path, |v: U| {
out.push(v);
Ok(())
})?;
Ok(out)
}
#[inline]
pub fn for_each_raw<F>(&self, mut f: F) -> Result<(), Error>
where
F: FnMut(&'a [u8]) -> Result<(), Error>,
{
for item in self.raw_elems() {
f(item?)?;
}
Ok(())
}
pub fn each_nested<F>(&self, mut f: F) -> Result<(), Error>
where
F: FnMut(crate::nested::NestedView<'a>) -> Result<(), Error>,
{
self.for_each_raw(|raw| f(crate::nested::NestedView::from_span(raw)))
}
pub fn each_nested_field<U, F>(&self, field_path: &str, mut f: F) -> Result<(), Error>
where
U: crate::convert::FromJsonSlice,
F: FnMut(U) -> Result<(), Error>,
{
let field = crate::path::try_parse_path(field_path)?;
self.for_each_raw(|raw| {
let slice = crate::scan::find_value(raw, &field)?;
let v = U::from_json_slice(slice).ok_or(Error::TypeMismatch {
expected: std::any::type_name::<U>(),
found: "invalid format",
})?;
f(v)
})
}
pub fn collect_nested_field<U: crate::convert::FromJsonSlice>(
&self,
field_path: &str,
) -> Result<Vec<U>, Error> {
let mut out = Vec::new();
self.each_nested_field(field_path, |v: U| {
out.push(v);
Ok(())
})?;
Ok(out)
}
pub fn sum_field_u64(&self, field_path: &str) -> Result<u64, Error> {
let mut sum = 0u64;
self.each_field(field_path, |v: u64| {
sum = sum.wrapping_add(v);
Ok(())
})?;
Ok(sum)
}
pub fn sum_nested_field_u64(&self, field_path: &str) -> Result<u64, Error> {
let mut sum = 0u64;
self.each_nested_field(field_path, |v: u64| {
sum = sum.wrapping_add(v);
Ok(())
})?;
Ok(sum)
}
}