use std::collections::HashMap;
use std::sync::Arc;
use super::{Built, ListIx, Map, Parsed, PrimArray, PrimRun, Value};
use crate::error::{LimitError, LimitKind};
use crate::limits::{Charge, ChargeError, Meter, MeteredVec, hash_table_cost};
use crate::typetree::NodeId;
pub struct ValueBuilder {
lists: MeteredVec<crate::typetree::SharedNodes>,
by_address: Option<ListTable>,
}
const _: () = crate::send_sync::<ValueBuilder>();
const SCANNED_LISTS: usize = 8;
struct ListTable {
index: HashMap<usize, usize>,
charge: Charge,
}
impl ListTable {
fn cost(n: usize) -> u64 {
hash_table_cost(n, size_of::<(usize, usize)>())
}
}
impl std::fmt::Debug for ValueBuilder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValueBuilder")
.field("lists", &self.lists.len())
.finish_non_exhaustive()
}
}
pub(super) fn owns_heap(value: &Value) -> bool {
match value {
Value::List(v) => v.capacity() > 0,
Value::Tuple(v) => !v.is_empty(),
Value::Dict(m) => m.entries.capacity() > 0,
Value::Prims(PrimArray::U8(_)) => false,
Value::Prims(p) => !p.is_empty(),
_ => false,
}
}
impl ValueBuilder {
pub fn new(
meter: &Arc<Meter>,
root: crate::typetree::SharedNodes,
) -> Result<Self, ChargeError> {
let mut lists = MeteredVec::new(meter);
lists.push(root)?;
Ok(Self {
lists,
by_address: None,
})
}
#[must_use]
pub fn meter(&self) -> &Arc<Meter> {
self.lists.charge().meter()
}
#[must_use]
pub fn vec<T>(&self) -> MeteredVec<T> {
MeteredVec::new(self.meter())
}
pub fn list_index(
&mut self,
list: &crate::typetree::SharedNodes,
) -> Result<ListIx, ChargeError> {
let addr = triomphe::Arc::as_ptr(list).addr();
let found = match &self.by_address {
Some(t) => {
crate::walk::steps(1);
t.index.get(&addr).copied()
}
None => self.lists.as_slice().iter().position(|l| {
crate::walk::steps(1);
triomphe::Arc::ptr_eq(l, list)
}),
};
let at = if let Some(at) = found {
at
} else {
self.push_list(list, addr)?
};
ListIx::try_from(at).map_err(|_| {
ChargeError::Limit(LimitError::refused(
LimitKind::Count,
u64::try_from(at).unwrap_or(u64::MAX),
u64::from(ListIx::MAX),
))
})
}
fn push_list(
&mut self,
list: &crate::typetree::SharedNodes,
addr: usize,
) -> Result<usize, ChargeError> {
let at = self.lists.len();
let n = at + 1;
match &mut self.by_address {
Some(t) => t
.charge
.grow(ListTable::cost(n).saturating_sub(ListTable::cost(n - 1)))?,
None if n > SCANNED_LISTS => {
let charge = self.meter().charge(ListTable::cost(n))?;
let mut index = HashMap::with_capacity(n);
for (i, l) in self.lists.as_slice().iter().enumerate() {
crate::walk::steps(1);
index.insert(triomphe::Arc::as_ptr(l).addr(), i);
}
self.by_address = Some(ListTable { index, charge });
}
None => {}
}
self.lists.push(list.clone())?;
if let Some(t) = &mut self.by_address {
t.index.insert(addr, at);
}
Ok(at)
}
pub fn scalar(&self, value: Value) -> Result<Built, Value> {
if owns_heap(&value) {
return Err(value);
}
Ok(Built {
value,
charge: Charge::zero(self.meter()),
})
}
#[must_use]
pub fn list(&self, items: MeteredVec<Value>) -> Built {
let (items, charge) = items.into_parts();
Built {
value: Value::List(items),
charge,
}
}
#[must_use]
pub fn map(&self, list: ListIx, entries: MeteredVec<(NodeId, Value)>) -> Built {
let (entries, charge) = entries.into_parts();
Built {
value: Value::Dict(Map { list, entries }),
charge,
}
}
pub fn tuple(&self, items: MeteredVec<Value>) -> Result<Built, ChargeError> {
let (items, charge) = items.into_boxed_slice()?;
Ok(Built {
value: Value::Tuple(items),
charge,
})
}
pub fn prims(&self, run: PrimRun) -> Result<Built, ChargeError> {
fn boxed<T>(
items: MeteredVec<T>,
wrap: fn(Box<[T]>) -> PrimArray,
) -> Result<Built, ChargeError> {
let (items, charge) = items.into_boxed_slice()?;
Ok(Built {
value: Value::Prims(wrap(items)),
charge,
})
}
match run {
PrimRun::Bool(v) => boxed(v, PrimArray::Bool),
PrimRun::I8(v) => boxed(v, PrimArray::I8),
PrimRun::U16(v) => boxed(v, PrimArray::U16),
PrimRun::I16(v) => boxed(v, PrimArray::I16),
PrimRun::U32(v) => boxed(v, PrimArray::U32),
PrimRun::I32(v) => boxed(v, PrimArray::I32),
PrimRun::U64(v) => boxed(v, PrimArray::U64),
PrimRun::I64(v) => boxed(v, PrimArray::I64),
PrimRun::F32(v) => boxed(v, PrimArray::F32),
PrimRun::F64(v) => boxed(v, PrimArray::F64),
}
}
#[must_use]
pub fn finish(self, value: Built, bytes_read: i64) -> Parsed {
let (lists, lists_charge) = self.lists.into_parts();
let Built { value, mut charge } = value;
charge.absorb(lists_charge);
Parsed {
lists,
value,
bytes_read,
read_by: super::ReadBy::Boost,
charge,
}
}
}