103 lines
2.2 KiB
Rust
103 lines
2.2 KiB
Rust
use std::{
|
|
cell::RefCell,
|
|
collections::{HashMap, HashSet},
|
|
rc::Rc,
|
|
};
|
|
|
|
use super::{
|
|
mod_tree::Module,
|
|
nodes,
|
|
path::{ItemPath, OwnedItemPath},
|
|
};
|
|
|
|
// requires mappings:
|
|
// names -> sets of references to individual objects
|
|
// paths -> individual objects
|
|
// glob paths -> sets of object refs
|
|
// (OPT/LATER) names (fuzzy) ~> sets of objects
|
|
#[derive(Debug)]
|
|
pub struct Registry {
|
|
defs: Vec<StoreObj<Def>>,
|
|
mods: Vec<StoreObj<Mod>>,
|
|
names: HashMap<String, HashSet<RegistryIdx>>,
|
|
paths: HashMap<OwnedItemPath, RegistryIdx>,
|
|
}
|
|
|
|
impl Registry {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
defs: Vec::new(),
|
|
mods: Vec::new(),
|
|
names: HashMap::new(),
|
|
paths: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
// TODO: rewrite. has lots of flaws
|
|
pub fn insert_mod(&mut self, path: ItemPath<'_>, module: Rc<Module>) -> Option<RegistryIdx> {
|
|
let idx = self.mods.len();
|
|
let Some(name) = path.name() else { return None };
|
|
self.mods.push(StoreObj::new(&name, Mod { module }));
|
|
|
|
if let Some(set) = self.names.get_mut(&name) {
|
|
set.insert(RegistryIdx::Mod(idx));
|
|
} else {
|
|
self.names
|
|
.insert(name, HashSet::from([RegistryIdx::Mod(idx)]));
|
|
}
|
|
|
|
if self
|
|
.paths
|
|
.get(&path.clone().into())
|
|
.is_some_and(|other_idx| *other_idx != RegistryIdx::Mod(idx))
|
|
{
|
|
return None;
|
|
} else {
|
|
self.paths.insert(path.into(), RegistryIdx::Mod(idx))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for Registry {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
|
|
pub enum RegistryIdx {
|
|
Def(usize),
|
|
Mod(usize),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct StoreObj<T> {
|
|
inner: Rc<InnerStoreObj<T>>,
|
|
}
|
|
|
|
impl<T> StoreObj<T> {
|
|
pub fn new(name: impl ToString, item: T) -> Self {
|
|
Self {
|
|
inner: Rc::new(InnerStoreObj {
|
|
name: name.to_string(),
|
|
obj: item,
|
|
}),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct InnerStoreObj<T> {
|
|
name: String,
|
|
obj: T,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Mod {
|
|
module: Rc<Module>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Def {
|
|
node: nodes::Def,
|
|
}
|