use crate::{EntitySchema, Schema};
use std::{fmt::Write, sync::Mutex};
#[doc(hidden)]
pub use ctor as __ctor;
#[derive(Debug)]
pub enum Error {
Poisoned,
LateRegistration,
DuplicatePath(&'static str),
InvalidModule,
EmptyModule,
Schema(crate::Error),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{self:?}")
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Schema(error) => Some(error),
_ => None,
}
}
}
#[derive(Default)]
struct Registry {
nodes: Vec<(&'static str, &'static EntitySchema)>,
sealed: bool,
late: bool,
}
impl Registry {
fn register(&mut self, path: &'static str, schema: &'static EntitySchema) {
if self.sealed {
self.late = true;
} else {
self.nodes.push((path, schema));
}
}
fn generate(&mut self, source: &str, target: &str) -> Result<String, Error> {
if self.late {
return Err(Error::LateRegistration);
}
if source.is_empty() || target.is_empty() {
return Err(Error::InvalidModule);
}
self.nodes.sort_by_key(|(path, _)| *path);
if let Some(pair) = self.nodes.windows(2).find(|pair| pair[0].0 == pair[1].0) {
return Err(Error::DuplicatePath(pair[0].0));
}
let prefix = format!("{source}::");
let mut selected: Vec<_> = self
.nodes
.iter()
.filter_map(|(path, schema)| path.strip_prefix(&prefix).map(|suffix| (suffix, *schema)))
.collect();
if selected.is_empty() {
return Err(Error::EmptyModule);
}
selected.sort_by_key(|(_, schema)| schema.name);
let schema = Schema::new(
&selected
.iter()
.map(|(_, schema)| *schema)
.collect::<Vec<_>>(),
)
.map_err(Error::Schema)?;
let mut code = String::from(
"// Generated from the validated host schema; do not edit.\n\
fn compiled() -> ::ic_db::Schema {\n\
::std::thread_local! { static SCHEMA: ::ic_db::Schema = {\n\
let schema = ::ic_db::Schema::new(&[\n",
);
for (path, _) in selected {
writeln!(code, "<{target}::{path} as ::ic_db::Entity>::SCHEMA,").unwrap();
}
code.push_str("] ).expect(\"generated schema admission failed\");\n");
writeln!(
code,
"assert_eq!(schema.fingerprint(), {:?}, \"host/target schema mismatch\");",
schema.fingerprint()
)
.unwrap();
code.push_str("schema\n}; }\nSCHEMA.with(::std::clone::Clone::clone)\n}\n");
self.sealed = true;
Ok(code)
}
}
static REGISTRY: Mutex<Registry> = Mutex::new(Registry {
nodes: Vec::new(),
sealed: false,
late: false,
});
#[doc(hidden)]
pub fn __register(path: &'static str, schema: &'static EntitySchema) {
REGISTRY
.lock()
.expect("schema registration lock poisoned")
.register(path, schema);
}
pub fn generate(source_module: &str, target_module: &str) -> Result<String, Error> {
REGISTRY
.lock()
.map_err(|_| Error::Poisoned)?
.generate(source_module, target_module)
}
#[cfg(test)]
mod tests;