use fhir_types::codec::Value;
use openehr_mapping_core::composition::CanonicalComposition;
use openehr_mapping_core::composition::RmPosition;
use openehr_mapping_core::index::WebTemplateIndex;
use crate::engine::context::CallContext;
use crate::engine::outcome::Outcome;
use crate::engine::seam::Seams;
use crate::engine::traverse::error::EngineError;
use crate::resolve::program::Program;
use crate::tree::element::Table;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StartOccurrence {
positions: Vec<u32>,
path: String,
}
impl StartOccurrence {
#[must_use]
pub fn positions(&self) -> &[u32] {
&self.positions
}
#[must_use]
pub fn path(&self) -> &str {
&self.path
}
}
pub fn occurrences(
program: &Program,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
) -> Result<Vec<StartOccurrence>, EngineError> {
super::composition_program(program)?;
let mut found = Vec::new();
for instance in super::root_instances(program, index, composition)? {
let Some(path) = super::entry_path(program, index, composition, &instance)? else {
continue;
};
found.push(StartOccurrence {
positions: instance.iter().map(|position| position.get()).collect(),
path,
});
}
Ok(found)
}
pub fn to_fhir_at<T: Table + ?Sized>(
program: &Program,
table: &T,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
seams: &Seams<'_>,
context: &CallContext,
occurrence: &StartOccurrence,
) -> Result<Outcome<Value>, EngineError> {
super::composition_program(program)?;
let mut instance = Vec::with_capacity(occurrence.positions.len());
for position in &occurrence.positions {
instance.push(
RmPosition::new(*position).map_err(|source| EngineError::Position {
mapping: String::from(program.context().as_str()),
source,
})?,
);
}
super::read_out(
program,
table,
index,
composition,
Some(composition),
seams,
context,
&instance,
)
}