use std::collections::HashMap;
use std::path::Path;
use bstack::BStack;
use linkme::distributed_slice;
use crate::primitives::{EightCC, WidePtr};
use super::{
RECORD_HEADER_LEN, RttiOrdinal, RttiType, class_value_slot, decode_type, encode_type,
frame_record, layouts_match, unknown_tag,
};
use super::{RttiResult, rtti_err};
pub struct RttiRegistration {
pub build: fn() -> RttiType,
}
#[distributed_slice]
pub static RTTI_TYPES: [RttiRegistration];
pub fn sync(path: impl AsRef<Path>) -> RttiResult<RttiRegistry> {
let mut reg = RttiRegistry::open(path)?;
reg.sync_compiled()?;
Ok(reg)
}
struct RecordRef {
tag: EightCC,
offset: u64,
body_len: u32,
}
pub struct RttiRegistry {
stack: BStack,
records: Vec<RecordRef>,
by_tag: HashMap<EightCC, RttiOrdinal>,
}
impl RttiRegistry {
pub fn open(path: impl AsRef<Path>) -> RttiResult<Self> {
let stack = BStack::open(path)?;
let mut reg = Self {
stack,
records: Vec::new(),
by_tag: HashMap::new(),
};
reg.scan()?;
Ok(reg)
}
fn scan(&mut self) -> RttiResult<()> {
let len = self.stack.len()?;
let mut off = 0u64;
while off < len {
let mut header = [0u8; RECORD_HEADER_LEN as usize];
self.stack.get_into(off, &mut header)?;
let tag = EightCC(header[0..8].try_into().unwrap());
let body_len = u32::from_le_bytes(header[8..12].try_into().unwrap());
if RECORD_HEADER_LEN + body_len as u64 > len - off {
return Err(rtti_err!(
Malformed,
"RTTI record body length runs past the end of the schema stack",
));
}
self.index(tag, off, body_len)?;
off += (RECORD_HEADER_LEN + body_len as u64 + 7) & !7;
}
Ok(())
}
fn index(&mut self, tag: EightCC, offset: u64, body_len: u32) -> RttiResult<RttiOrdinal> {
let ordinal = self.records.len() as RttiOrdinal;
if self.by_tag.insert(tag, ordinal).is_some() {
return Err(rtti_err!(
Malformed,
"duplicate RTTI eightcc — two types share one tag",
));
}
self.records.push(RecordRef {
tag,
offset,
body_len,
});
Ok(ordinal)
}
pub fn append(&mut self, ty: &RttiType) -> RttiResult<RttiOrdinal> {
if self.by_tag.contains_key(&ty.tag) {
return Err(rtti_err!(
Malformed,
"duplicate RTTI eightcc — type already registered",
));
}
let body = encode_type(ty)?;
let (record, body_len) = frame_record(ty.tag, &body)?;
let offset = self.stack.push(&record)?;
self.index(ty.tag, offset, body_len)
}
pub fn sync_compiled(&mut self) -> RttiResult<usize> {
let mut appended = 0;
let mut seen: HashMap<EightCC, RttiType> = HashMap::new();
for reg in RTTI_TYPES.iter() {
let ty = (reg.build)();
if let Some(prev) = seen.get(&ty.tag) {
if prev.name != ty.name {
return Err(rtti_err!(
Collision,
"RTTI eightcc collision: '{}' and '{}' \
hash to one tag",
prev.name,
ty.name
));
}
if !layouts_match(prev, &ty) {
return Err(rtti_err!(
Collision,
"RTTI eightcc collision: two distinct types \
both named '{}' (same-named types in different modules?) \
share one tag",
ty.name
));
}
continue; }
seen.insert(ty.tag, ty.clone());
match self.ordinal_of(ty.tag) {
Some(ord) => {
let existing = self.load_type(ord)?;
if existing.name != ty.name {
return Err(rtti_err!(
Collision,
"RTTI eightcc collision: on-disk '{}' vs \
compiled '{}' share one tag",
existing.name,
ty.name
));
}
if !layouts_match(&existing, &ty) {
return Err(rtti_err!(
SchemaMismatch,
"RTTI schema mismatch for '{}': the persisted \
layout differs from the compiled type (a field was added, \
removed, reordered, or resized). The on-disk data was \
written against the old layout.",
ty.name
));
}
}
None => {
self.append(&ty)?;
appended += 1;
}
}
}
Ok(appended)
}
pub fn len(&self) -> usize {
self.records.len()
}
pub fn is_empty(&self) -> bool {
self.records.is_empty()
}
pub fn ordinal_of(&self, tag: EightCC) -> Option<RttiOrdinal> {
self.by_tag.get(&tag).copied()
}
pub fn tag_of(&self, ordinal: RttiOrdinal) -> Option<EightCC> {
self.records.get(ordinal as usize).map(|r| r.tag)
}
pub fn resolve_ptr(&self, ptr: WidePtr) -> Option<RttiOrdinal> {
let ord = ptr.type_id().ordinal()?;
((ord as usize) < self.records.len()).then_some(ord)
}
pub fn load_type(&self, ordinal: RttiOrdinal) -> RttiResult<RttiType> {
let rec = self
.records
.get(ordinal as usize)
.ok_or_else(|| rtti_err!(OrdinalRange, "RTTI ordinal out of range"))?;
let mut body = vec![0u8; rec.body_len as usize];
self.stack
.get_into(rec.offset + RECORD_HEADER_LEN, &mut body)?;
decode_type(rec.tag, &body)
}
pub fn class_value(&self, tag: EightCC, name: &str) -> RttiResult<Vec<u8>> {
let (off, len, _mutable) = self.locate_class_value(tag, name)?;
let mut buf = vec![0u8; len];
self.stack.get_into(off, &mut buf)?;
Ok(buf)
}
pub fn set_class_value(&self, tag: EightCC, name: &str, value: &[u8]) -> RttiResult<()> {
let (off, len, mutable) = self.locate_class_value(tag, name)?;
if !mutable {
return Err(rtti_err!(
Class,
"RTTI class variable: `{}` is a const class variable; only a \
`#[bstack_mut]` one is settable",
name
));
}
if value.len() != len {
return Err(rtti_err!(
Class,
"RTTI class variable: class variable `{}` is {} bytes, got {}",
name,
len,
value.len()
));
}
self.stack.set(off, value).map_err(Into::into)
}
fn locate_class_value(&self, tag: EightCC, name: &str) -> RttiResult<(u64, usize, bool)> {
let ord = self.ordinal_of(tag).ok_or_else(unknown_tag)?;
let rec = &self.records[ord as usize];
let mut body = vec![0u8; rec.body_len as usize];
self.stack
.get_into(rec.offset + RECORD_HEADER_LEN, &mut body)?;
let (pos, len, mutable) = class_value_slot(&body, name)?.ok_or_else(|| {
rtti_err!(
Class,
"RTTI class variable: no class variable named `{}`",
name
)
})?;
Ok((rec.offset + RECORD_HEADER_LEN + pos as u64, len, mutable))
}
}