use bytes::Bytes;
use crate::limits::{Charge, ChargeError, MeteredVec};
use crate::raw::RawStr;
use crate::typetree::NodeId;
pub type ListIx = u32;
#[derive(Debug)]
pub struct Parsed {
lists: Vec<crate::typetree::SharedNodes>,
value: Value,
pub bytes_read: i64,
read_by: ReadBy,
charge: Charge,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ReadBy {
#[default]
Boost,
Python,
}
impl PartialEq for Parsed {
fn eq(&self, other: &Self) -> bool {
self.lists == other.lists
&& self.value == other.value
&& self.bytes_read == other.bytes_read
&& self.read_by == other.read_by
}
}
impl Eq for Parsed {}
#[derive(Debug, PartialEq, Eq)]
pub enum Value {
Bool(bool),
Int(i64),
UInt(u64),
F32(u32),
F64(u64),
Str(RawStr),
Bytes(Bytes),
Prims(PrimArray),
List(Vec<Value>),
Tuple(Box<[Value]>),
Dict(Map),
}
#[derive(Debug, PartialEq, Eq)]
pub enum PrimArray {
Bool(Box<[bool]>),
U8(Bytes),
I8(Box<[i8]>),
U16(Box<[u16]>),
I16(Box<[i16]>),
U32(Box<[u32]>),
I32(Box<[i32]>),
U64(Box<[u64]>),
I64(Box<[i64]>),
F32(Box<[u32]>),
F64(Box<[u64]>),
}
impl PrimArray {
#[must_use]
pub fn len(&self) -> usize {
match self {
Self::Bool(v) => v.len(),
Self::U8(v) => v.len(),
Self::I8(v) => v.len(),
Self::U16(v) => v.len(),
Self::I16(v) => v.len(),
Self::U32(v) | Self::F32(v) => v.len(),
Self::I32(v) => v.len(),
Self::U64(v) | Self::F64(v) => v.len(),
Self::I64(v) => v.len(),
}
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
#[derive(Debug, PartialEq, Eq, Default)]
pub struct Map {
list: ListIx,
entries: Vec<(NodeId, Value)>,
}
impl Map {
#[must_use]
pub fn new(list: ListIx) -> Self {
Self {
list,
entries: Vec::new(),
}
}
#[must_use]
pub fn from_entries(list: ListIx, entries: Vec<(NodeId, Value)>) -> Self {
Self { list, entries }
}
#[must_use]
pub fn list(&self) -> ListIx {
self.list
}
#[cfg(test)]
pub(crate) fn insert(&mut self, key: NodeId, value: Value) {
match self.entries.iter_mut().find(|(k, _)| *k == key) {
Some((_, v)) => *v = value,
None => self.entries.push((key, value)),
}
}
#[cfg(test)]
pub(crate) fn capacity(&self) -> usize {
self.entries.capacity()
}
#[must_use]
pub fn entries(&self) -> &[(NodeId, Value)] {
&self.entries
}
#[must_use]
pub fn get(&self, key: NodeId) -> Option<&Value> {
self.entries.iter().find(|(k, _)| *k == key).map(|(_, v)| v)
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
#[derive(Debug)]
pub struct Built {
value: Value,
charge: Charge,
}
impl Built {
#[must_use]
pub fn value(&self) -> &Value {
&self.value
}
#[must_use]
pub fn charge(&self) -> &Charge {
&self.charge
}
}
impl MeteredVec<Value> {
pub fn push_built(&mut self, item: Built) -> Result<(), ChargeError> {
self.push_charged(item.value, item.charge)
}
}
impl MeteredVec<(NodeId, Value)> {
pub fn push_entry(&mut self, key: NodeId, item: Built) -> Result<(), ChargeError> {
self.push_charged((key, item.value), item.charge)
}
pub fn set_entry(&mut self, pos: usize, item: Built) -> bool {
let Built { value, charge } = item;
match self.as_mut_slice().get_mut(pos) {
Some((_, v)) => {
*v = value;
self.keep_charge(charge);
true
}
None => false,
}
}
}
#[derive(Debug)]
pub enum PrimRun {
Bool(MeteredVec<bool>),
I8(MeteredVec<i8>),
U16(MeteredVec<u16>),
I16(MeteredVec<i16>),
U32(MeteredVec<u32>),
I32(MeteredVec<i32>),
U64(MeteredVec<u64>),
I64(MeteredVec<i64>),
F32(MeteredVec<u32>),
F64(MeteredVec<u64>),
}
impl Parsed {
#[cfg(test)]
pub(crate) fn for_tests(
lists: Vec<crate::typetree::SharedNodes>,
value: Value,
bytes_read: i64,
) -> Self {
Self {
lists,
value,
bytes_read,
read_by: ReadBy::Boost,
charge: Charge::zero(&crate::limits::Meter::unlimited()),
}
}
pub(crate) fn with_read_by(mut self, read_by: ReadBy) -> Self {
self.read_by = read_by;
self
}
#[must_use]
pub fn read_by(&self) -> ReadBy {
self.read_by
}
#[must_use]
pub fn value(&self) -> &Value {
&self.value
}
pub(crate) fn value_mut(&mut self) -> &mut Value {
&mut self.value
}
#[must_use]
pub fn charge(&self) -> &Charge {
&self.charge
}
#[must_use]
pub fn lists(&self) -> &[crate::typetree::SharedNodes] {
&self.lists
}
#[must_use]
pub fn key_name(&self, map: &Map, key: NodeId) -> &[u8] {
usize::try_from(map.list)
.ok()
.and_then(|i| self.lists.get(i))
.map_or(&[], |l| l.name(key))
}
pub fn entries<'a>(
&'a self,
map: &'a Map,
) -> impl ExactSizeIterator<Item = (&'a [u8], &'a Value)> + 'a {
map.entries()
.iter()
.map(move |(k, v)| (self.key_name(map, *k), v))
}
#[must_use]
pub fn field<'a>(&'a self, map: &'a Map, name: &[u8]) -> Option<&'a Value> {
self.entries(map).find(|(n, _)| *n == name).map(|(_, v)| v)
}
#[must_use]
pub fn attr<'a>(&'a self, map: &'a Map, name: &[u8]) -> Option<&'a Value> {
let list = usize::try_from(map.list)
.ok()
.and_then(|i| self.lists.get(i));
let node = map
.entries()
.first()
.and_then(|(k, _)| k.0.checked_sub(1))
.map(crate::typetree::NodeId);
let kids = match (list, node) {
(Some(l), Some(n)) if l.children(n).first() == map.entries().first().map(|e| &e.0) => {
l.children(n)
}
_ => &[],
};
if let Some(list) = list.filter(|_| !kids.is_empty()) {
let raw = kids
.iter()
.rev()
.map(|k| list.name(*k))
.find(|n| crate::walk::write::cleans_to(n, name))?;
return self.field(map, raw);
}
self.entries(map)
.filter(|(n, _)| crate::walk::write::cleans_to(n, name))
.last()
.map(|(_, v)| v)
}
#[must_use]
pub fn get(&self, path: &[&[u8]]) -> Option<&Value> {
let mut v = &self.value;
for name in path {
let Value::Dict(m) = v else { return None };
v = self.field(m, name)?;
}
Some(v)
}
}
impl Value {
#[must_use]
pub fn as_i64(&self) -> Option<i64> {
match self {
Self::Int(i) => Some(*i),
Self::UInt(u) => i64::try_from(*u).ok(),
_ => None,
}
}
#[must_use]
pub fn as_u64(&self) -> Option<u64> {
match self {
Self::Int(i) => u64::try_from(*i).ok(),
Self::UInt(u) => Some(*u),
_ => None,
}
}
#[must_use]
pub fn as_f64(&self) -> Option<f64> {
match self {
Self::F32(b) => Some(f64::from(f32::from_bits(*b))),
Self::F64(b) => Some(f64::from_bits(*b)),
_ => None,
}
}
#[must_use]
pub fn as_bool(&self) -> Option<bool> {
match self {
Self::Bool(b) => Some(*b),
_ => None,
}
}
#[must_use]
pub fn as_str(&self) -> Option<&str> {
match self {
Self::Str(s) => s.to_str(),
_ => None,
}
}
#[must_use]
pub fn as_bytes(&self) -> Option<&[u8]> {
match self {
Self::Str(s) => Some(s.as_bytes()),
Self::Bytes(b) | Self::Prims(PrimArray::U8(b)) => Some(b),
_ => None,
}
}
#[must_use]
pub fn as_shared_bytes(&self) -> Option<&Bytes> {
match self {
Self::Bytes(b) | Self::Prims(PrimArray::U8(b)) => Some(b),
_ => None,
}
}
#[must_use]
pub fn as_dict(&self) -> Option<&Map> {
match self {
Self::Dict(m) => Some(m),
_ => None,
}
}
}
mod builder;
mod edit;
mod flat;
pub use builder::ValueBuilder;
#[cfg(test)]
mod tests;