use crate::limits::Meter;
use crate::typetree::{NodeId, NodeList};
use crate::{Map, Parsed, PrimArray, RawStr, Value};
use self::error::ViewError as MeshError;
mod error;
pub use error::ViewError;
pub const NAME_BYTES: usize = 64;
struct TypeName<'a>(&'a [u8]);
fn type_name(ty: &[u8]) -> TypeName<'_> {
TypeName(ty)
}
impl std::fmt::Display for TypeName<'_> {
fn fmt(&self, out: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use std::fmt::Write;
let mut written = 0;
for &b in self.0 {
let escaped = b.escape_ascii();
if written + escaped.len() > NAME_BYTES {
return out.write_str("…");
}
written += escaped.len();
for c in escaped {
out.write_char(char::from(c))?;
}
}
Ok(())
}
}
struct TypeNames(&'static [&'static str]);
impl std::fmt::Display for TypeNames {
fn fmt(&self, out: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for (i, ty) in self.0.iter().enumerate() {
if i > 0 {
out.write_str(" or ")?;
}
out.write_str(ty)?;
}
Ok(())
}
}
fn count(meter: &Meter, n: usize) -> Result<(), MeshError> {
meter.count_decode(u64::try_from(n).unwrap_or(u64::MAX))?;
Ok(())
}
pub use classes::*;
mod classes;
fn clean_name_is(name: &[u8], target: &str) -> bool {
let name = name.strip_prefix(b"(int&)").unwrap_or(name);
let name = name.strip_suffix(b"?").unwrap_or(name);
let target = target.as_bytes();
name.len() == target.len()
&& name.iter().zip(target).all(|(&a, &b)| {
let a = if b" .:-[]".contains(&a) { b'_' } else { a };
a == b
})
}
fn builds(list: &NodeList, node: NodeId, class: &Class, meter: &Meter) -> Result<bool, MeshError> {
let kids = list.children(node);
let fields = class.required.len().saturating_add(class.optional.len());
let per_child = class
.required
.len()
.saturating_add(if class.slotted { fields } else { 0 });
count(meter, kids.len().saturating_mul(per_child))?;
let has = |f: &str| kids.iter().any(|&c| clean_name_is(list.name(c), f));
let is_field = |c: NodeId| {
class
.required
.iter()
.chain(class.optional)
.any(|f| clean_name_is(list.name(c), f))
};
Ok(class.required.iter().all(|f| has(f))
&& (!class.slotted || kids.iter().all(|&c| is_field(c))))
}
#[derive(Clone, Copy, Debug)]
pub struct Obj<'a> {
list: &'a NodeList,
node: NodeId,
map: &'a Map,
built: bool,
meter: &'a Meter,
}
const _: () = crate::send_sync::<Obj<'static>>();
impl<'a> Obj<'a> {
pub fn root(
parsed: &'a Parsed,
class: &'static Class,
meter: &'a Meter,
) -> Result<Self, MeshError> {
let list = parsed.lists().first().ok_or_else(|| {
MeshError::malformed(format_args!("{}", "a value without a tree"), meter)
})?;
Self::new(
list,
list.root(),
parsed.value(),
class,
"the object",
meter,
)
}
fn new(
list: &'a NodeList,
node: NodeId,
value: &'a Value,
class: &'static Class,
field: &str,
meter: &'a Meter,
) -> Result<Self, MeshError> {
let ty = list.type_name(node);
if !class.types.iter().any(|t| t.as_bytes() == ty) {
return Err(MeshError::malformed(
format_args!(
"{field} has type {}, not {}",
type_name(ty),
TypeNames(class.types)
),
meter,
));
}
let Value::Dict(map) = value else {
return Err(MeshError::malformed(
format_args!("{field} is not a class"),
meter,
));
};
if map.list() != 0 {
return Err(MeshError::malformed(
format_args!("{field} is read through a referenced type"),
meter,
));
}
Ok(Self {
list,
node,
map,
built: builds(list, node, class, meter)?,
meter,
})
}
#[must_use]
pub fn built(&self) -> bool {
self.built
}
fn child(&self, name: &str) -> Option<NodeId> {
self.list
.children(self.node)
.iter()
.rev()
.find(|&&c| clean_name_is(self.list.name(c), name))
.copied()
}
pub fn get(&self, name: &'static str) -> Result<Option<(NodeId, &'a Value)>, MeshError> {
let scanned = self
.list
.children(self.node)
.len()
.saturating_add(self.map.entries().len());
count(self.meter, scanned)?;
let found = self.child(name).and_then(|c| {
let raw = self.list.name(c);
self.map
.entries()
.iter()
.find(|(k, _)| self.list.name(*k) == raw)
.map(|(_, v)| (c, v))
});
match found {
Some(hit) => Ok(Some(hit)),
None if self.built => Ok(None),
None => Err(MeshError::NoAttribute(name)),
}
}
pub fn uint(&self, name: &'static str, max: u64) -> Result<Option<u64>, MeshError> {
let Some((_, v)) = self.get(name)? else {
return Ok(None);
};
let n = match v {
Value::Bool(b) => Some(u64::from(*b)),
Value::Int(i) => u64::try_from(*i).ok(),
Value::UInt(u) => Some(*u),
_ => {
return Err(MeshError::malformed(
format_args!("{name} is not an integer"),
self.meter,
));
}
};
match n {
Some(n) if n <= max => Ok(Some(n)),
_ => Err(MeshError::malformed(
format_args!("{name} is out of its range"),
self.meter,
)),
}
}
pub fn int32(&self, name: &'static str) -> Result<Option<i64>, MeshError> {
let Some((_, v)) = self.get(name)? else {
return Ok(None);
};
let n = match v {
Value::Bool(b) => i64::from(*b),
Value::Int(i) if i32::try_from(*i).is_ok() => *i,
Value::Int(_) | Value::UInt(_) => {
return Err(MeshError::malformed(
format_args!("{name} is out of its range"),
self.meter,
));
}
_ => {
return Err(MeshError::malformed(
format_args!("{name} is not an integer"),
self.meter,
));
}
};
Ok(Some(n))
}
pub fn float(&self, name: &'static str) -> Result<Option<f64>, MeshError> {
match self.get(name)? {
None => Ok(None),
Some((_, Value::F32(bits))) => Ok(Some(widen(*bits))),
Some((_, Value::F64(bits))) => Ok(Some(f64::from_bits(*bits))),
Some(_) => Err(MeshError::malformed(
format_args!("{name} is not a float"),
self.meter,
)),
}
}
pub fn bytes(&self, name: &'static str) -> Result<Option<&'a [u8]>, MeshError> {
match self.get(name)? {
None => Ok(None),
Some((_, Value::Bytes(b))) => Ok(Some(b)),
Some(_) => Err(MeshError::malformed(
format_args!("{name} is not bytes"),
self.meter,
)),
}
}
pub fn string(&self, name: &'static str) -> Result<Option<&'a RawStr>, MeshError> {
match self.get(name)? {
None => Ok(None),
Some((_, Value::Str(s))) => Ok(Some(s)),
Some(_) => Err(MeshError::malformed(
format_args!("{name} is not a string"),
self.meter,
)),
}
}
pub fn class(
&self,
name: &'static str,
class: &'static Class,
) -> Result<Option<Obj<'a>>, MeshError> {
match self.get(name)? {
None => Ok(None),
Some((node, v)) => Self::new(self.list, node, v, class, name, self.meter).map(Some),
}
}
pub fn list(
&self,
name: &'static str,
class: &'static Class,
) -> Result<Option<List<'a>>, MeshError> {
let Some((node, v)) = self.get(name)? else {
return Ok(None);
};
let items: &'a [Value] = match v {
Value::List(items) => items,
Value::Tuple(items) => items,
Value::Prims(p) if p.is_empty() => &[],
_ => {
return Err(MeshError::malformed(
format_args!("{name} is not a list of classes"),
self.meter,
));
}
};
let elem = match self.list.children(node) {
[array, ..] => match self.list.children(*array) {
[_, elem] => Some(*elem),
_ => None,
},
[] => None,
};
let Some(elem) = elem else {
return Err(MeshError::malformed(
format_args!("{name} is not a vector"),
self.meter,
));
};
Ok(Some(List {
nodes: self.list,
elem,
items,
class,
name,
built: builds(self.list, elem, class, self.meter)?,
meter: self.meter,
}))
}
pub fn ints(&self, name: &'static str) -> Result<Option<Ints<'a>>, MeshError> {
match self.get(name)? {
None => Ok(None),
Some((_, v)) => Ints::of(v, name, self.meter).map(Some),
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct List<'a> {
nodes: &'a NodeList,
elem: NodeId,
items: &'a [Value],
class: &'static Class,
name: &'static str,
built: bool,
meter: &'a Meter,
}
const _: () = crate::send_sync::<List<'static>>();
impl<'a> List<'a> {
#[must_use]
pub fn len(&self) -> usize {
self.items.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[must_use]
pub fn get(&self, i: usize) -> Option<Result<Obj<'a>, MeshError>> {
let v = self.items.get(i)?;
Some(self.element(v))
}
fn element(&self, v: &'a Value) -> Result<Obj<'a>, MeshError> {
let ty = self.nodes.type_name(self.elem);
if !self.class.types.iter().any(|t| t.as_bytes() == ty) {
return Err(MeshError::malformed(
format_args!("{}'s elements have type {}", self.name, type_name(ty)),
self.meter,
));
}
let Value::Dict(map) = v else {
return Err(MeshError::malformed(
format_args!("{}'s elements are not classes", self.name),
self.meter,
));
};
if map.list() != 0 {
return Err(MeshError::malformed(
format_args!("{} is read through a referenced type", self.name),
self.meter,
));
}
Ok(Obj {
list: self.nodes,
node: self.elem,
map,
built: self.built,
meter: self.meter,
})
}
pub fn iter(&self) -> impl Iterator<Item = Result<Obj<'a>, MeshError>> + '_ {
self.items.iter().map(|v| self.element(v))
}
}
#[derive(Clone, Copy, Debug)]
pub enum Ints<'a> {
Run(&'a PrimArray, &'a Meter),
Items(&'a [Value], &'static str, &'a Meter),
Raw(&'a [u8], &'a Meter),
}
const _: () = crate::send_sync::<Ints<'static>>();
impl<'a> Ints<'a> {
fn meter(&self) -> &Meter {
match self {
Self::Run(_, m) | Self::Items(_, _, m) | Self::Raw(_, m) => m,
}
}
fn of(v: &'a Value, name: &'static str, meter: &'a Meter) -> Result<Self, MeshError> {
match v {
Value::Prims(p) => match p {
PrimArray::F32(_) | PrimArray::F64(_) if !p.is_empty() => Err(
MeshError::malformed(format_args!("{name} is not a list of integers"), meter),
),
_ => Ok(Self::Run(p, meter)),
},
Value::List(items) => Ok(Self::Items(items, name, meter)),
Value::Tuple(items) => Ok(Self::Items(items, name, meter)),
Value::Bytes(b) => Ok(Self::Raw(b, meter)),
_ => Err(MeshError::malformed(
format_args!("{name} is not a list"),
meter,
)),
}
}
#[must_use]
pub fn len(&self) -> usize {
match self {
Self::Run(p, _) => p.len(),
Self::Items(items, _, _) => items.len(),
Self::Raw(b, _) => b.len(),
}
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn byte(&self, i: usize) -> Result<u8, MeshError> {
fn byte<T: TryInto<u8>>(v: Option<T>) -> Result<u8, MeshError> {
v.map_or(Ok(0), |v| v.try_into().map_err(|_| MeshError::ByteRange))
}
match self {
Self::Run(p, _) => match p {
PrimArray::U8(b) => Ok(b.get(i).copied().unwrap_or(0)),
PrimArray::Bool(v) => Ok(v.get(i).copied().map_or(0, u8::from)),
PrimArray::I8(v) => byte(v.get(i).copied()),
PrimArray::U16(v) => byte(v.get(i).copied()),
PrimArray::I16(v) => byte(v.get(i).copied()),
PrimArray::U32(v) => byte(v.get(i).copied()),
PrimArray::I32(v) => byte(v.get(i).copied()),
PrimArray::U64(v) => byte(v.get(i).copied()),
PrimArray::I64(v) => byte(v.get(i).copied()),
PrimArray::F32(_) | PrimArray::F64(_) => Ok(0),
},
Self::Items(items, name, _) => match items.get(i) {
None => Ok(0),
Some(Value::Bool(b)) => Ok(u8::from(*b)),
Some(Value::Int(v)) => byte(Some(*v)),
Some(Value::UInt(v)) => byte(Some(*v)),
Some(_) => Err(MeshError::malformed(
format_args!("{name} holds a value that is not an integer"),
self.meter(),
)),
},
Self::Raw(b, _) => Ok(b.get(i).copied().unwrap_or(0)),
}
}
pub fn item(&self, i: usize) -> Result<Option<u8>, MeshError> {
if i >= self.len() {
return Ok(None);
}
match self.byte(i) {
Ok(b) => Ok(Some(b)),
Err(MeshError::ByteRange) => Err(MeshError::malformed(
format_args!("{}", "m_Data holds a value past a byte"),
self.meter(),
)),
Err(e) => Err(e),
}
}
#[must_use]
pub fn is_bytes(&self) -> bool {
matches!(self, Self::Raw(_, _))
}
#[must_use]
pub fn as_u8(&self) -> Option<&'a [u8]> {
match self {
Self::Run(PrimArray::U8(b), _) => Some(b),
Self::Raw(b, _) => Some(b),
_ => None,
}
}
}
fn widen(bits: u32) -> f64 {
let value = f32::from_bits(bits);
if value.is_nan() {
f64::from_bits(
(u64::from(bits >> 31) << 63)
| 0x7ff0_0000_0000_0000
| (u64::from((bits & 0x007f_ffff) | 0x0040_0000) << 29),
)
} else {
f64::from(value)
}
}
#[cfg(test)]
mod tests {
use super::{NAME_BYTES, type_name};
#[test]
fn a_type_name_is_cut_between_escapes() {
assert_eq!(type_name(b"Mesh").to_string(), "Mesh");
let exact = "x".repeat(NAME_BYTES);
assert_eq!(type_name(exact.as_bytes()).to_string(), exact);
let long = "y".repeat(1 << 20);
assert_eq!(
type_name(long.as_bytes()).to_string(),
format!("{}…", &long[..NAME_BYTES])
);
let cut = type_name(&[0xFF; 100]).to_string();
assert_eq!(cut, format!("{}…", "\\xff".repeat(NAME_BYTES / 4)));
let mut ty = vec![b'a'; NAME_BYTES - 2];
ty.push(0xFF);
assert_eq!(
type_name(&ty).to_string(),
format!("{}…", "a".repeat(NAME_BYTES - 2))
);
}
}