pub mod build;
pub mod convert;
pub mod defaults;
pub mod demographic;
pub mod display;
pub mod error;
pub mod event;
mod frame;
pub mod functions;
pub mod links;
pub mod manual;
pub mod occurrence;
pub mod party;
pub mod place;
pub mod programmed;
pub mod reference;
pub mod split;
pub mod tail;
pub mod translate;
mod unread;
pub mod walk;
use std::collections::BTreeMap;
use fhir_types::codec::Object;
use fhir_types::codec::Value;
use fhir_types::r4::coding::Coding;
use openehr_mapping_core::composition::CanonicalComposition;
use openehr_mapping_core::composition::CanonicalDocument;
use openehr_mapping_core::composition::NodeValue;
use openehr_mapping_core::composition::RmPosition;
use openehr_mapping_core::index::WebTemplateIndex;
use openehr_mapping_core::index::paths::FlatId;
use crate::engine::context::CallContext;
use crate::engine::family;
use crate::engine::invariant;
use crate::engine::lens::null_flavour::NullFlavour;
use crate::engine::outcome::Location;
use crate::engine::outcome::Outcome;
use crate::engine::outcome::Warning;
use crate::engine::rm::RmValue;
use crate::engine::seam::Seams;
use crate::engine::subject::SubjectIdentifier;
use crate::model::ast::keyword::Direction;
use crate::resolve::program::Program;
use crate::resolve::program::target::ListAxis;
use crate::resolve::program::target::OpenehrTarget;
use crate::tree::Occurrence;
use crate::tree::element::Table;
use crate::engine::traverse::defaults::Defaults;
use crate::engine::traverse::error::EngineError;
const INSTANCE_CEILING: u32 = 1024;
const LINK_TYPE: &str = "reference";
#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct Binding {
fhir: Occurrence,
openehr: Vec<RmPosition>,
axes: Vec<FlatId>,
elements: Vec<RmPosition>,
lists: Vec<ListAxis>,
level: usize,
}
impl Binding {
fn shared(&self, axes: &[FlatId]) -> usize {
self.axes
.iter()
.zip(axes)
.zip(&self.openehr)
.take_while(|&((held, wanted), _)| held == wanted)
.count()
}
fn keeping_openehr(&self, fhir: Occurrence, level: usize) -> Self {
Self {
fhir,
openehr: self.openehr.clone(),
axes: self.axes.clone(),
elements: self.elements.clone(),
lists: self.lists.clone(),
level,
}
}
fn shared_lists(&self, target: &OpenehrTarget) -> usize {
let depth = target.occurrences().len();
if self.shared(target.occurrences()) != depth || self.openehr.len() != depth {
return 0;
}
self.lists
.iter()
.zip(target.lists())
.zip(&self.elements)
.take_while(|&((held, wanted), _)| held == wanted)
.count()
}
fn of_openehr(
&self,
target: Option<&OpenehrTarget>,
fhir: Occurrence,
mut positions: Vec<RmPosition>,
level: usize,
) -> Self {
let Some(target) = target else {
return Self {
fhir,
axes: self.axes_of(None, positions.len()),
openehr: positions,
elements: self.elements.clone(),
lists: self.lists.clone(),
level,
};
};
let depth = target.occurrences().len().min(positions.len());
let elements = positions.split_off(depth);
let lists = target
.lists()
.get(..elements.len())
.unwrap_or(target.lists())
.to_vec();
Self {
fhir,
axes: self.axes_of(Some(target), positions.len()),
openehr: positions,
elements,
lists,
level,
}
}
fn axes_of(&self, target: Option<&OpenehrTarget>, held: usize) -> Vec<FlatId> {
let axes = target.map_or(self.axes.as_slice(), OpenehrTarget::occurrences);
axes.get(..held).unwrap_or(axes).to_vec()
}
}
#[derive(Debug)]
struct Frame {
document: Value,
occurrence: Occurrence,
pin: Option<(Vec<String>, Occurrence)>,
counters: BTreeMap<(String, String), usize>,
}
#[derive(Debug, Clone, PartialEq)]
struct Written {
flat_id: FlatId,
positions: Vec<RmPosition>,
value: Held,
}
#[derive(Debug, Clone, PartialEq)]
enum Held {
Value(RmValue),
Partial(serde_json::Map<String, serde_json::Value>),
Canonical(serde_json::Value),
}
#[derive(Debug, Clone, PartialEq)]
enum Leaf {
Value(Box<RmValue>),
Scalar(String),
NullFlavour(Box<NullFlavour>),
}
pub fn to_openehr<T: Table + ?Sized>(
program: &Program,
table: &T,
index: &WebTemplateIndex,
document: &Value,
seams: &Seams<'_>,
defaults: &Defaults,
context: &CallContext,
) -> Result<Outcome<CanonicalComposition>, EngineError> {
composition_program(program)?;
let mut run = Run::new(
program,
table,
index,
Direction::FhirToOpenehr,
*seams,
context,
document.clone(),
None,
);
run.pins = program
.root_axes()
.iter()
.map(|axis| (axis.clone(), RmPosition::first()))
.collect();
run.whole_program()?;
let mut defaulted = run.apply_defaults(defaults)?;
let unplaced = run.place_facility(defaults, &mut defaulted)?;
if let Some(origin) = defaults.origin() {
run.families.extend(family::feeder_audit(
index.root(),
origin,
&defaulted,
defaults.facility.as_ref().filter(|_| unplaced),
));
}
let (values, routed) = run.node_values()?;
let built = index
.build_composition(&values, &defaults.start_time)
.map_err(|source| EngineError::Build {
source: Box::new(source),
})?;
let built = run.amend_intervals(built)?;
run.carried_whole(&built, &routed)?;
Ok(Outcome::new(built, run.warnings)
.with_consumed(run.consumed)
.with_subject(run.subject)
.with_reads(run.reads))
}
pub fn to_fhir<T: Table + ?Sized>(
program: &Program,
table: &T,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
seams: &Seams<'_>,
context: &CallContext,
) -> Result<Outcome<Value>, EngineError> {
composition_program(program)?;
let instances = root_instances(program, index, composition)?;
let first = instances.first().cloned().unwrap_or_default();
let mut outcome = read_out(
program,
table,
index,
composition,
Some(composition),
seams,
context,
&first,
)?;
let further = instances.len().saturating_sub(1);
if further > 0 {
outcome.warn(Warning::new(
crate::engine::outcome::Loss::UnmappedOccurrences {
archetype: start_archetype(program),
count: further,
},
Location::default(),
));
}
Ok(outcome)
}
#[derive(Debug)]
pub enum Each {
Mapped {
occurrence: Vec<u32>,
path: String,
outcome: Outcome<Value>,
},
NotApplicable {
occurrence: Vec<u32>,
path: String,
},
}
pub fn to_fhir_each<T: Table + ?Sized>(
program: &Program,
table: &T,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
seams: &Seams<'_>,
context: &CallContext,
) -> Result<Vec<Each>, EngineError> {
composition_program(program)?;
let mut each = Vec::new();
for instance in root_instances(program, index, composition)? {
let occurrence: Vec<u32> = instance.iter().map(|position| position.get()).collect();
let Some(path) = entry_path(program, index, composition, &instance)? else {
continue;
};
match read_out(
program,
table,
index,
composition,
Some(composition),
seams,
context,
&instance,
) {
Ok(outcome) => each.push(Each::Mapped {
occurrence,
path,
outcome,
}),
Err(EngineError::NotApplicable { .. }) => {
each.push(Each::NotApplicable { occurrence, path });
}
Err(error) => return Err(error),
}
}
Ok(each)
}
fn root_instances(
program: &Program,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
) -> Result<Vec<Vec<RmPosition>>, EngineError> {
let mut found: Vec<Vec<RmPosition>> = vec![Vec::new()];
for axis in program.root_axes() {
let refuse = |source| EngineError::Template {
mapping: String::from(program.context().as_str()),
node: String::from(axis.as_str()),
source: Box::new(source),
};
let node = index.node_by_flat_id(axis).map_err(refuse)?;
let mut deeper = Vec::new();
for prefix in found {
let mut instance = 1u32;
while instance <= INSTANCE_CEILING {
let mut positions = prefix.clone();
positions.push(RmPosition::new(instance).map_err(|source| {
EngineError::Position {
mapping: String::from(program.context().as_str()),
source,
}
})?);
if !index.holds(composition, node, &positions).map_err(refuse)? {
break;
}
deeper.push(positions);
instance = instance.saturating_add(1);
}
}
found = deeper;
}
Ok(found)
}
fn entry_path(
program: &Program,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
instance: &[RmPosition],
) -> Result<Option<String>, EngineError> {
let Some(root) = program.root() else {
return Ok(Some(String::from(crate::engine::identity::ROOT_PATH)));
};
let refuse = |source| EngineError::Template {
mapping: String::from(program.context().as_str()),
node: String::from(root.as_str()),
source: Box::new(source),
};
let node = index.node_by_flat_id(root).map_err(refuse)?;
let named = index
.entry_path(composition, node, instance)
.map_err(refuse)?;
Ok(named.map(|path| {
let rendered = path.to_string();
if rendered.is_empty() {
String::from(crate::engine::identity::ROOT_PATH)
} else {
rendered
}
}))
}
pub(crate) fn start_archetype(program: &Program) -> String {
program
.models()
.iter()
.find(|model| model.name() == program.start())
.and_then(|model| model.archetype())
.map(ToString::to_string)
.unwrap_or_default()
}
#[expect(
clippy::too_many_arguments,
reason = "the three composition entry points and the party one share this one run"
)]
fn read_out<T: Table + ?Sized>(
program: &Program,
table: &T,
index: &WebTemplateIndex,
document: &dyn CanonicalDocument,
composition: Option<&CanonicalComposition>,
seams: &Seams<'_>,
context: &CallContext,
instance: &[RmPosition],
) -> Result<Outcome<Value>, EngineError> {
let mut run = Run::new(
program,
table,
index,
Direction::OpenehrToFhir,
*seams,
context,
empty_resource(program.resource().as_str()),
Some(document),
);
run.pins = program
.root_axes()
.iter()
.cloned()
.zip(instance.iter().copied())
.collect();
run.whole_program()?;
if let Some(composition) = composition {
let read = run.carried.take();
let unread = unread::unread(program, index, composition, instance, &read)?;
let named: std::collections::BTreeSet<String> = run
.warnings
.iter()
.filter_map(|warning| warning.location().openehr().map(String::from))
.collect();
run.warnings.extend(unread.into_iter().filter(|warning| {
warning
.location()
.openehr()
.is_none_or(|path| !named.contains(path))
}));
}
let created = core::mem::take(&mut run.created);
for document in core::iter::once(&run.fhir).chain(&created) {
invariant::check(document).map_err(|breach| EngineError::Invariant {
context: String::from(program.context().as_str()),
breach,
})?;
}
Ok(Outcome::new(run.fhir, run.warnings).with_created(created))
}
fn composition_program(program: &Program) -> Result<(), EngineError> {
match program.party() {
Some(party) => Err(EngineError::PartyProgram {
context: String::from(program.context().as_str()),
party,
}),
None => Ok(()),
}
}
fn empty_resource(resource_type: &str) -> Value {
let mut resource = Object::new();
resource.insert(
String::from("resourceType"),
Value::String(String::from(resource_type)),
);
Value::Object(resource)
}
struct Run<'a, T: Table + ?Sized> {
program: &'a Program,
table: &'a T,
index: &'a WebTemplateIndex,
direction: Direction,
seams: Seams<'a>,
context: &'a CallContext,
warnings: Vec<Warning>,
fhir: Value,
composition: Option<&'a dyn CanonicalDocument>,
written: Vec<Written>,
families: Vec<NodeValue>,
facility_written: bool,
context_keys: Vec<NodeValue>,
expected: Vec<Routed>,
counters: BTreeMap<(String, String), usize>,
chain: Vec<String>,
references: Vec<String>,
linked_to: Option<String>,
frames: Vec<Frame>,
created: Vec<Value>,
consumed: Vec<String>,
pins: Vec<(FlatId, RmPosition)>,
fhir_pin: Option<(Vec<String>, Occurrence)>,
translations: BTreeMap<translate::TranslationKey, Option<Coding>>,
subject: Vec<SubjectIdentifier>,
intervals: Vec<event::Interval>,
reads: Vec<Location>,
carried: core::cell::RefCell<std::collections::BTreeSet<unread::Instance>>,
}
impl<T: Table + ?Sized> Run<'_, T> {
fn whole_program(&mut self) -> Result<(), EngineError> {
self.admits_context()?;
let program = self.program;
self.split_or_run(
program.mappings(),
program.hierarchy(),
program.start().as_str(),
&Binding::default(),
)
}
}
impl<'a, T: Table + ?Sized> Run<'a, T> {
#[expect(
clippy::too_many_arguments,
reason = "a run is assembled once per entry point from exactly the inputs the two entry points take"
)]
fn new(
program: &'a Program,
table: &'a T,
index: &'a WebTemplateIndex,
direction: Direction,
seams: Seams<'a>,
context: &'a CallContext,
fhir: Value,
composition: Option<&'a dyn CanonicalDocument>,
) -> Self {
Self {
program,
table,
index,
direction,
seams,
context,
warnings: Vec::new(),
fhir,
composition,
written: Vec::new(),
families: Vec::new(),
facility_written: false,
context_keys: Vec::new(),
expected: Vec::new(),
counters: BTreeMap::new(),
chain: Vec::new(),
references: Vec::new(),
linked_to: None,
frames: Vec::new(),
created: Vec::new(),
consumed: Vec::new(),
pins: Vec::new(),
fhir_pin: None,
translations: BTreeMap::new(),
subject: Vec::new(),
intervals: Vec::new(),
reads: Vec::new(),
carried: core::cell::RefCell::default(),
}
}
}
fn openehr_path(target: &OpenehrTarget) -> String {
let mut path = String::from(target.node().aql_path().as_str());
for segment in &target.tail().segments {
path.push('/');
path.push_str(segment.attribute.as_str());
}
if path.is_empty() {
path.push('/');
}
path
}
type Routed = (FlatId, RmValue);