use super::read::{Container, ValueRef};
use super::tag::{ARRAY, MAP, width};
use super::{Error, varint};
#[derive(Clone, Copy, Debug)]
pub struct Item<'a> {
bytes: &'a [u8],
}
impl<'a> Item<'a> {
#[inline(always)]
pub const fn new(bytes: &'a [u8]) -> Self {
Self {
bytes,
}
}
#[inline(always)]
pub const fn bytes(&self) -> &'a [u8] {
self.bytes
}
#[inline(always)]
pub fn tag(&self) -> Result<u8, Error> {
self.bytes.first().copied().ok_or(Error::Truncated)
}
#[inline(always)]
pub fn value(&self) -> Result<ValueRef<'a>, Error> {
ValueRef::new(self.bytes)
}
#[inline]
pub fn map(&self) -> Result<Option<MapRef<'a>>, Error> {
let (&t, p) = self.bytes.split_first().ok_or(Error::Truncated)?;
match t {
MAP..=MAP_MAX => Ok(Some(MapRef {
c: Container::split(p, width(t, MAP))?,
})),
_ => Ok(None),
}
}
#[inline]
pub fn list(&self) -> Result<Option<ListRef<'a>>, Error> {
let (&t, p) = self.bytes.split_first().ok_or(Error::Truncated)?;
match t {
ARRAY..=ARRAY_MAX => Ok(Some(ListRef {
c: Container::split(p, width(t, ARRAY))?,
})),
_ => Ok(None),
}
}
}
const MAP_MAX: u8 = MAP + 2;
const ARRAY_MAX: u8 = ARRAY + 2;
#[derive(Clone, Copy, Debug)]
pub struct MapRef<'a> {
c: Container<'a>,
}
impl<'a> MapRef<'a> {
#[inline(always)]
pub fn len(&self) -> usize {
self.c.n
}
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.c.n == 0
}
#[inline]
pub fn entry(&self, i: usize) -> Result<(u32, Item<'a>), Error> {
let bytes = self.c.entry(i)?;
let (number, used) = varint::read_u64(bytes)
.map_err(|_| Error::Malformed("a map entry number is malformed"))?;
let number = u32::try_from(number)
.ok()
.filter(|&n| n != 0)
.ok_or(Error::Malformed("a map entry number is malformed"))?;
match bytes.get(used..) {
Some(item) if !item.is_empty() => Ok((number, Item::new(item))),
_ => Err(Error::Malformed("a map entry has no item")),
}
}
pub fn get(&self, n: u32) -> Result<Option<Item<'a>>, Error> {
let (mut lo, mut hi) = (0, self.c.n);
let (mut below, mut above) = (None::<u32>, None::<u32>);
while lo < hi {
let mid = lo + (hi - lo) / 2;
let (k, item) = self.entry(mid)?;
if below.is_some_and(|b| k <= b) || above.is_some_and(|a| k >= a) {
return Err(Error::Malformed("map entry numbers are not strictly ascending"));
}
match k.cmp(&n) {
std::cmp::Ordering::Equal => return Ok(Some(item)),
std::cmp::Ordering::Less => {
lo = mid + 1;
below = Some(k);
}
std::cmp::Ordering::Greater => {
hi = mid;
above = Some(k);
}
}
}
Ok(None)
}
pub fn validate(&self) -> Result<(), Error> {
let mut prev = None::<u32>;
for i in 0..self.c.n {
let (k, _) = self.entry(i)?;
if prev.is_some_and(|p| k <= p) {
return Err(Error::Malformed("map entry numbers are not strictly ascending"));
}
prev = Some(k);
}
Ok(())
}
}
#[derive(Clone, Copy, Debug)]
pub struct ListRef<'a> {
c: Container<'a>,
}
impl<'a> ListRef<'a> {
#[inline(always)]
pub fn len(&self) -> usize {
self.c.n
}
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.c.n == 0
}
#[inline]
pub fn get(&self, i: usize) -> Result<Item<'a>, Error> {
Ok(Item::new(self.c.entry(i)?))
}
}