pub mod derived;
pub mod fhir;
pub mod header;
pub mod hierarchy;
pub mod mapping;
pub mod method;
pub mod openehr;
pub mod party;
pub mod port;
use std::path::PathBuf;
use std::sync::Arc;
use openehr_mapping_core::diagnostic::Diagnostic;
use openehr_mapping_core::diagnostic::ModelPath;
use openehr_mapping_core::diagnostic::Severity;
use openehr_mapping_core::header::metadata::MappingName;
use openehr_mapping_core::index::ResolvedNode;
use openehr_mapping_core::index::WebTemplateIndex;
use openehr_rm::v1_2::paths::RmPath;
use crate::model::ast::ContextMappingFile;
use crate::model::ast::ModelMappingFile;
use crate::model::ast::keyword::ContextScope;
use crate::model::ast::keyword::DataType;
use crate::model::ast::keyword::Direction;
use crate::model::load::MappingSet;
use crate::model::semantic::MappingCodeRegistry;
use crate::resolve::error::ResolveCode;
use crate::resolve::extensions::diagnostic;
use crate::resolve::program::Program;
use crate::resolve::program::ProgramParts;
use crate::resolve::program::binding::ModelBinding;
use crate::resolve::program::binding::ResourceType;
use crate::resolve::program::target::FhirTarget;
use crate::resolve::program::target::OpenehrTarget;
use crate::tree::element::Table;
use crate::tree::path::FhirPath;
use openehr_mapping_core::party::PartyClass;
use crate::resolve::compile::fhir::root_expression;
use crate::resolve::compile::openehr::compaction_map;
use crate::resolve::compile::openehr::interior_paths;
use crate::resolve::compile::openehr::occurrences;
pub fn compile(
set: &MappingSet,
context: &MappingName,
template: &WebTemplateIndex,
table: &dyn Table,
codes: &dyn MappingCodeRegistry,
) -> Result<Arc<Program>, Vec<Diagnostic>> {
let mut compiler = Compiler::new(set, template, table, codes);
let program = compiler.run(context);
let refused = compiler
.diagnostics
.iter()
.any(|diagnostic| diagnostic.severity() == Severity::Error);
match program {
Some(program) if !refused => Ok(Arc::new(program.with_warnings(compiler.diagnostics))),
_ => Err(compiler.diagnostics),
}
}
#[derive(Debug, Clone)]
struct Scope {
resource: ResourceType,
fhir: FhirPath,
archetype: RmPath,
openehr: RmPath,
direction: Option<Direction>,
enclosing: Vec<Enclosing>,
file: PathBuf,
conceptmap: Option<String>,
prefix: String,
chain: Vec<MappingName>,
entered_at: Vec<RmPath>,
nested: bool,
element_root: Option<FhirPath>,
}
impl Scope {
fn anchored_at(&self, target: &FhirTarget) -> Self {
let climbed = self.enclosing.len().saturating_sub(target.level());
let mut scope = Self {
fhir: target.expression().clone(),
..self.clone()
};
if let Some(outer) = climbed
.checked_sub(1)
.and_then(|index| self.enclosing.get(index))
{
scope.resource = outer.resource.clone();
scope.enclosing = self.enclosing.iter().skip(climbed).cloned().collect();
}
scope
}
fn name_of(&self, name: &str) -> String {
if self.prefix.is_empty() {
name.to_owned()
} else {
format!("{}.{name}", self.prefix)
}
}
}
#[derive(Debug, Clone)]
struct Enclosing {
resource: ResourceType,
fhir: FhirPath,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Site {
Write(Option<Direction>),
ReadOnly,
}
#[derive(Debug, Clone, Copy)]
struct Derivation<'target> {
fhir: Option<&'target FhirTarget>,
openehr: Option<&'target OpenehrTarget>,
data_type: Option<DataType>,
direction: Option<Direction>,
plain: bool,
children: bool,
}
struct Compiler<'a> {
set: &'a MappingSet,
template: &'a WebTemplateIndex,
table: &'a dyn Table,
codes: &'a dyn MappingCodeRegistry,
compacted: Vec<(RmPath, &'a ResolvedNode)>,
interior: Vec<RmPath>,
extensions: Vec<&'a ModelMappingFile>,
diagnostics: Vec<Diagnostic>,
models: Vec<ModelBinding>,
entered: Vec<&'a ContextMappingFile>,
subs: Vec<&'a ContextMappingFile>,
party: Option<PartyClass>,
}
impl<'a> Compiler<'a> {
fn new(
set: &'a MappingSet,
template: &'a WebTemplateIndex,
table: &'a dyn Table,
codes: &'a dyn MappingCodeRegistry,
) -> Self {
Self {
set,
template,
table,
codes,
compacted: compaction_map(template),
interior: interior_paths(template),
extensions: Vec::new(),
diagnostics: Vec::new(),
models: Vec::new(),
entered: Vec::new(),
subs: Vec::new(),
party: PartyClass::from_rm_type(template.root().rm_type()),
}
}
fn refuses_as_root(&mut self, file: &ContextMappingFile) -> bool {
let declaration = file.context();
if declaration.scope() != ContextScope::Sub {
return false;
}
let context = file.header().name().value();
let position = declaration.scope.as_ref().map_or(
declaration.position,
openehr_mapping_core::position::Located::position,
);
self.diagnostics.push(diagnostic(
file.file(),
context,
ResolveCode::SubContextAsRoot,
position,
&ModelPath::root().field("context").field("scope"),
format!("`{context}` is `scope: sub`, so it is entered through `slotContext` only"),
));
true
}
fn run(&mut self, context: &MappingName) -> Option<Program> {
let Some(file) = self.set.context(context) else {
self.diagnostics.push(
Diagnostic::error(
PathBuf::new(),
ResolveCode::UnknownContext.into(),
format!("`{context}` is no context mapping of the loaded set"),
)
.with_mapping_name(context.clone()),
);
return None;
};
let declaration = file.context();
if self.refuses_as_root(file) {
return None;
}
self.entered.push(file);
let profile = Self::profile_of(file);
let template = self.template_of(file);
let start_name = declaration.start.value();
let start = self.set.model(start_name).or_else(|| {
self.diagnostics.push(diagnostic(
file.file(),
context,
ResolveCode::UnknownContextReference,
declaration.start.position(),
&ModelPath::root().field("context").field("start"),
format!("`{start_name}` is no model mapping of the loaded set"),
));
None
})?;
self.extensions = self.extensions_of(file);
let resource = self.resource_of(start)?;
let archetype = self.archetype_root(start)?;
let root = self
.template
.nodes()
.find(|node| *node.rm_path() == archetype);
let root_node = root.map(|node| node.flat_id().clone());
let root_axes = match root.map(|node| occurrences(self.template, node)) {
Some(Ok(axes)) => axes,
None => Vec::new(),
Some(Err(error)) => {
self.diagnostics.push(diagnostic(
start.file(),
start_name,
ResolveCode::UnresolvedArchetypeRoot,
start.spec().position,
&ModelPath::root().field("spec").field("openEhrConfig"),
format!("the repeating nodes above `{archetype}` do not resolve: {error}"),
));
return None;
}
};
let scope = Scope {
resource: resource.clone(),
fhir: root_expression(),
archetype: archetype.clone(),
entered_at: vec![archetype.clone()],
openehr: archetype,
direction: start.spec().unidirectional.as_ref().map(|d| *d.value()),
enclosing: Vec::new(),
file: start.file().to_path_buf(),
conceptmap: start
.spec()
.conceptmap
.as_ref()
.map(|url| url.value().clone()),
prefix: String::new(),
chain: vec![start_name.clone()],
nested: false,
element_root: None,
};
let merged = self.merge(start);
let mappings = self.mappings(&merged.mappings, &scope);
let preprocessors = self.preprocessors(start, &scope);
self.unreached_extensions(file);
for sub in core::mem::take(&mut self.subs) {
self.unreached_extensions(sub);
}
Some(
Program::new(ProgramParts {
context: context.clone(),
profile,
template,
resource,
start: start_name.clone(),
models: core::mem::take(&mut self.models),
operational: declaration
.operational
.iter()
.map(|name| name.value().clone())
.collect(),
preprocessors,
mappings,
})
.with_root_axes(root_axes)
.with_root(root_node)
.with_party(self.party),
)
}
}