use core::str::FromStr;
use std::borrow::Cow;
use fhir_types::codec::Value;
use openehr_mapping_core::composition::RmPosition;
use openehr_rm::v1_2::data_types::text::code_phrase::CodePhrase;
use crate::engine::cell;
use crate::engine::fhir::FhirKind;
use crate::engine::fhir::FhirValue;
use crate::engine::lens::Lens;
use crate::engine::lens::LensError;
use crate::engine::lens::null_flavour;
use crate::engine::lens::null_flavour::NullFlavour;
use crate::engine::lens::null_flavour::NullFlavourLens;
use crate::engine::lens::scalar;
use crate::engine::lens::scalar::IntegerLens;
use crate::engine::lens::scalar::RealLens;
use crate::engine::lens::term_mapping::Withheld;
use crate::engine::outcome::Loss;
use crate::engine::outcome::SkipReason;
use crate::engine::outcome::Warning;
use crate::engine::rm;
use crate::engine::rm::RmValue;
use crate::engine::rm::carried::Carried;
use crate::model::ast::keyword::Direction;
use crate::resolve::program::manual::Manual;
use crate::resolve::program::manual::ManualValue;
use crate::resolve::program::mapping::Derived;
use crate::resolve::program::mapping::Mapping;
use crate::resolve::program::target::FhirTarget;
use crate::resolve::program::target::OpenehrTarget;
use crate::tree::Occurrence;
use crate::tree::element::Table;
use crate::engine::traverse::Binding;
use crate::engine::traverse::Leaf;
use crate::engine::traverse::Run;
use crate::engine::traverse::Written;
use crate::engine::traverse::demographic::Shape;
use crate::engine::traverse::error::EngineError;
use crate::engine::traverse::place::rm_positions;
use crate::engine::traverse::tail::tail_segments;
use crate::engine::traverse::tail::unsupported_tail;
use crate::engine::traverse::translate::Output;
impl<T: Table + ?Sized> Run<'_, T> {
pub(super) fn manual_text<'run>(
&'run self,
mapping: &Mapping,
entry: &Manual,
value: &'run ManualValue,
) -> Result<&'run str, EngineError> {
match *value {
ManualValue::Literal(ref text) => Ok(text.as_str()),
ManualValue::Context(ref member) => {
self.context
.member(member)
.ok_or_else(|| EngineError::ContextMember {
mapping: format!("{}.{}", mapping.name(), entry.name()),
member: member.clone(),
})
}
}
}
pub(super) fn values(
&mut self,
mapping: &Mapping,
parent: &Binding,
inputs: &[Occurrence],
) -> Result<Vec<Binding>, EngineError> {
let inputs = self.held_inputs(mapping, inputs)?;
let inputs = inputs.as_ref();
let bindings = self.bindings(mapping, parent, inputs)?;
if !mapping.manual().is_empty() {
for entry in mapping.manual() {
for binding in &bindings {
self.manual(mapping, entry, binding)?;
}
}
return Ok(bindings);
}
if mapping.data_type() == Some(crate::model::ast::keyword::DataType::None)
|| matches!(mapping.derived(), Some(Derived::Anchor))
{
return Ok(bindings);
}
let (Some(_fhir), Some(_openehr)) = (mapping.fhir(), mapping.openehr()) else {
return Ok(bindings);
};
if let Some(openehr) = converted(mapping).filter(|target| target.ends_on_list()) {
return Err(unsupported_tail(mapping, openehr));
}
for (input, binding) in inputs.iter().zip(bindings.iter()) {
self.convert(mapping, input, binding)?;
if self.direction == Direction::FhirToOpenehr {
self.reads.push(self.locate(mapping, input));
}
}
Ok(bindings)
}
fn held_inputs<'inputs>(
&self,
mapping: &Mapping,
inputs: &'inputs [Occurrence],
) -> Result<Cow<'inputs, [Occurrence]>, EngineError> {
let leaf = self.direction == Direction::OpenehrToFhir
&& mapping.manual().is_empty()
&& mapping.followed_by().is_empty()
&& mapping.data_type() != Some(crate::model::ast::keyword::DataType::None)
&& !matches!(mapping.derived(), Some(Derived::Anchor | Derived::Event(_)))
&& converted(mapping).is_some_and(|target| !target.ends_on_list());
let Some(target) = mapping.fhir().filter(|_| leaf) else {
return Ok(Cow::Borrowed(inputs));
};
let mut held = Vec::with_capacity(inputs.len());
for input in inputs {
if self.output_source(mapping, target, input)?.is_some() {
held.push(input.clone());
}
}
Ok(Cow::Owned(held))
}
fn read_value(
&self,
value: &RmValue,
kind: FhirKind,
terminology: Option<&str>,
) -> Result<(FhirValue, Dropped), LensError> {
let (value, reference) = self.minted(value);
let dropped = Dropped {
code: cell::withheld::uncarried_code(&value, kind).cloned(),
mappings: cell::withheld::withheld(&value, kind, terminology),
reason: false,
};
let mut view = cell::get(&value, kind, terminology)?;
if let (Some(reference), FhirValue::Reference(held)) = (reference, &mut view) {
held.reference = Some(fhir_types::r4::primitives::String::from(reference));
}
Ok((view, dropped))
}
fn convert(
&mut self,
mapping: &Mapping,
input: &Occurrence,
binding: &Binding,
) -> Result<(), EngineError> {
if let Some(Derived::Event(event)) = mapping.derived() {
return match self.direction {
Direction::FhirToOpenehr => self.event_in(mapping, event, input, binding),
Direction::OpenehrToFhir => self.event_out(mapping, event, input, binding),
};
}
match self.direction {
Direction::FhirToOpenehr => self.convert_in(mapping, input, binding),
Direction::OpenehrToFhir => self.convert_out(mapping, input, binding),
}
}
fn convert_in(
&mut self,
mapping: &Mapping,
input: &Occurrence,
binding: &Binding,
) -> Result<(), EngineError> {
let Some(target) = mapping.fhir() else {
return Ok(());
};
let found = match mapping.derived() {
Some(Derived::Polymorphic { read, pairings }) => {
self.polymorphic_in(mapping, read, pairings, input)?
}
_ => match converted(mapping) {
Some(openehr) => self
.input_value(mapping, target, openehr, input)?
.map(|view| (openehr, view)),
None => None,
},
};
let Some((openehr, view)) = found else {
return Ok(());
};
let node = openehr.node();
let Some(view) = self.translated(mapping, view, Output::openehr(openehr, input))? else {
return Ok(());
};
if !openehr.tail().segments.is_empty() {
return self.convert_tail(mapping, target, openehr, &view, binding);
}
let held = self.held(&binding.openehr, node.flat_id());
let mut produced = cell::put(
&view,
node.rm_type(),
held.as_ref(),
self.binding_of(node).as_deref(),
self.index.ordinal_options(node).unwrap_or_default(),
)
.map_err(|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
})?;
self.resolve_display(mapping, &view, &mut produced)?;
for taken in &produced.fallbacks {
self.warnings
.push(Warning::fallback(taken, self.locate(mapping, input)));
}
let value = self.identified(mapping, &view, produced.value, Shape::at(node))?;
self.put_openehr_at(openehr, binding, value);
Ok(())
}
fn convert_out(
&mut self,
mapping: &Mapping,
input: &Occurrence,
binding: &Binding,
) -> Result<(), EngineError> {
let Some(target) = mapping.fhir() else {
return Ok(());
};
let Some((openehr, source, target, kind)) = self.output_source(mapping, target, input)?
else {
return Ok(());
};
let refuse = |source: LensError| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
};
let (view, dropped) = match source {
Leaf::Value(ref value) if let RmValue::PartyRef(ref party) = **value => (
self.reference_of_party(mapping, target, party)?,
Dropped::default(),
),
Leaf::Value(ref value) => {
let terminology = self.binding_of(openehr.node());
self.read_value(value, kind, terminology.as_deref())
.map_err(refuse)?
}
Leaf::Scalar(ref text) => (
Self::read_scalar(mapping, target, openehr, kind, text)?,
Dropped::default(),
),
Leaf::NullFlavour(ref flavour) => (
read_null_flavour(flavour, kind).map_err(refuse)?,
Dropped {
reason: null_flavour::uncarried_reason(flavour).is_some(),
..Dropped::default()
},
),
};
let output = Output::fhir(target, &binding.fhir);
let Some(view) = self.translated(mapping, view, output)? else {
return Ok(());
};
self.put_fhir_at(mapping, target, binding, &view)?;
self.record_dropped(mapping, binding, &dropped);
Ok(())
}
fn output_source<'mapping>(
&self,
mapping: &'mapping Mapping,
target: &'mapping FhirTarget,
input: &Occurrence,
) -> Result<Option<OutSource<'mapping>>, EngineError> {
if let Some(Derived::Polymorphic { pairings, .. }) = mapping.derived() {
let Some(first) = pairings.first() else {
return Ok(None);
};
let positions = Self::positions_of(mapping, input, first.target())?;
for pairing in pairings {
let openehr = pairing.target();
let Some(source) = self.value_at(mapping, openehr, &positions)? else {
continue;
};
let written = pairing.alternative();
let kind = FhirKind::of_code(written.code()).ok_or_else(|| {
EngineError::UnknownElement {
mapping: String::from(mapping.name()),
element: String::from(written.target().resolved().leaf()),
}
})?;
return Ok(Some((openehr, source, written.target(), kind)));
}
if self.node_held(mapping.name(), first.target(), &positions)? {
return Err(other_alternative(mapping, target, first.target()));
}
return Ok(None);
}
let Some(openehr) = converted(mapping) else {
return Ok(None);
};
let positions = Self::positions_of(mapping, input, openehr)?;
let Some(source) = self.value_at(mapping, openehr, &positions)? else {
if matches!(mapping.derived(), Some(Derived::Value { .. }))
&& self.node_held(mapping.name(), openehr, &positions)?
{
return Err(other_alternative(mapping, target, openehr));
}
return Ok(None);
};
let (target, kind) = Self::output_target(mapping, target)?;
Ok(Some((openehr, source, target, kind)))
}
fn read_scalar(
mapping: &Mapping,
target: &FhirTarget,
openehr: &OpenehrTarget,
kind: FhirKind,
text: &str,
) -> Result<FhirValue, EngineError> {
let refuse = |source: LensError| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
};
match kind {
FhirKind::Coding | FhirKind::Identifier | FhirKind::Reference
if openehr.leaf_class() == Some(cell::STRING) =>
{
cell::get_string(text, kind).map_err(refuse)
}
FhirKind::Integer | FhirKind::Decimal
if let Some(read) = scalar_number(openehr, kind, text) =>
{
read.map_err(refuse)
}
FhirKind::String
| FhirKind::Date
| FhirKind::DateTime
| FhirKind::Instant
| FhirKind::Time
| FhirKind::Url => {
let element = target.resolved().leaf();
FhirValue::read(kind, element, &Value::String(String::from(text))).map_err(
|source| EngineError::Fhir {
mapping: String::from(mapping.name()),
element: String::from(element),
source: Box::new(source),
},
)
}
FhirKind::Boolean
| FhirKind::Coding
| FhirKind::CodeableConcept
| FhirKind::Period
| FhirKind::Reference
| FhirKind::Identifier
| FhirKind::Quantity
| FhirKind::Integer
| FhirKind::UnsignedInt
| FhirKind::PositiveInt
| FhirKind::Decimal
| FhirKind::Count
| FhirKind::Duration
| FhirKind::Attachment
| FhirKind::Range => Err(refuse(LensError::NoCell {
rm_type: String::from(openehr.leaf_class().unwrap_or(cell::STRING)),
kind: kind.as_str(),
direction: Direction::OpenehrToFhir,
})),
}
}
fn record_dropped(&mut self, mapping: &Mapping, binding: &Binding, dropped: &Dropped) {
if dropped.code.is_none() && dropped.mappings.is_empty() && !dropped.reason {
return;
}
let location = self.locate(mapping, &binding.fhir);
let below = |attribute: &str| match location.openehr() {
Some(path) => location.clone().with_openehr(format!("{path}/{attribute}")),
None => location.clone(),
};
if let Some(ref code) = dropped.code {
self.warnings.push(Warning::uncarried_code(
mapping.name(),
code,
below("defining_code"),
));
}
let mappings = below("mappings");
for taken in &dropped.mappings {
self.warnings
.push(Warning::withheld(mapping.name(), taken, mappings.clone()));
}
if dropped.reason {
self.warnings.push(Warning::new(
Loss::Skipped {
mapping: String::from(mapping.name()),
reason: SkipReason::NullReasonUncarried,
},
location.clone(),
));
}
}
fn input_value(
&self,
mapping: &Mapping,
target: &FhirTarget,
openehr: &OpenehrTarget,
input: &Occurrence,
) -> Result<Option<FhirValue>, EngineError> {
match mapping.derived() {
Some(Derived::Choice { read, .. } | Derived::Polymorphic { read, .. }) => {
self.choice_at(mapping, read, openehr, input)
}
Some(Derived::Declared(declared)) => {
let kind = Self::kind(mapping, declared.target())?;
self.element_at(mapping, declared.target(), input, kind)
}
Some(
Derived::Element(_) | Derived::Anchor | Derived::Value { .. } | Derived::Event(_),
)
| None => {
let kind = Self::kind(mapping, target)?;
self.element_at(mapping, target, input, kind)
}
}
}
fn output_target<'mapping>(
mapping: &'mapping Mapping,
target: &'mapping FhirTarget,
) -> Result<(&'mapping FhirTarget, FhirKind), EngineError> {
match mapping.derived() {
Some(Derived::Choice {
write: Some(written),
..
}) => {
let kind = FhirKind::of_code(written.code()).ok_or_else(|| {
EngineError::UnknownElement {
mapping: String::from(mapping.name()),
element: String::from(written.target().resolved().leaf()),
}
})?;
Ok((written.target(), kind))
}
Some(Derived::Declared(declared)) => {
Ok((declared.target(), Self::kind(mapping, declared.target())?))
}
Some(Derived::Choice { write: None, .. } | Derived::Polymorphic { .. }) => {
Err(EngineError::UnknownElement {
mapping: String::from(mapping.name()),
element: String::from(target.resolved().leaf()),
})
}
Some(
Derived::Element(_) | Derived::Anchor | Derived::Value { .. } | Derived::Event(_),
)
| None => Ok((target, Self::kind(mapping, target)?)),
}
}
pub(super) fn store(&mut self, written: Written) {
if let Some(slot) = self
.written
.iter_mut()
.find(|held| held.flat_id == written.flat_id && held.positions == written.positions)
{
*slot = written;
} else {
self.written.push(written);
}
}
pub(super) fn positions_of(
mapping: &Mapping,
input: &Occurrence,
target: &OpenehrTarget,
) -> Result<Vec<RmPosition>, EngineError> {
let depth = target
.occurrences()
.len()
.saturating_add(target.lists().len());
let taken = input.indices().get(..depth).unwrap_or(input.indices());
let mut positions = rm_positions(mapping.name(), taken)?;
positions.resize(depth, RmPosition::first());
Ok(positions)
}
}
fn converted(mapping: &Mapping) -> Option<&OpenehrTarget> {
match mapping.derived() {
Some(Derived::Value { target, .. }) => Some(target),
_ => mapping.openehr(),
}
}
fn scalar_number(
openehr: &OpenehrTarget,
kind: FhirKind,
text: &str,
) -> Option<Result<FhirValue, LensError>> {
let carried = rm::carried::carried(openehr.tail_class(), &tail_segments(openehr))
.map(|(_, carried)| carried);
let unreadable = |cell: &'static str, attribute: &'static str| LensError::Shape {
cell,
attribute,
found: String::from(text),
reason: "the composition holds no number there",
direction: Direction::OpenehrToFhir,
};
match (carried, kind) {
(Some(Carried::Integer), FhirKind::Integer) => Some(
text.parse::<i64>()
.map_err(|_refused| unreadable(scalar::INTEGER_CELL, "Integer"))
.and_then(|number| IntegerLens.get(&number))
.map(FhirValue::Integer),
),
(Some(Carried::Real), FhirKind::Decimal) => Some(
serde_json::Number::from_str(text)
.map_err(|_refused| unreadable(scalar::REAL_CELL, "Real"))
.and_then(|number| RealLens.get(&number))
.map(FhirValue::Decimal),
),
_ => None,
}
}
fn other_alternative(mapping: &Mapping, target: &FhirTarget, node: &OpenehrTarget) -> EngineError {
EngineError::UnknownElement {
mapping: String::from(mapping.name()),
element: format!(
"{} from another value alternative at `{}`",
target.resolved().leaf(),
node.node().aql_path().as_str()
),
}
}
fn read_null_flavour(flavour: &NullFlavour, kind: FhirKind) -> Result<FhirValue, LensError> {
match kind {
FhirKind::String => NullFlavourLens.get(flavour).map(FhirValue::String),
other => Err(LensError::NoCell {
rm_type: String::from("ELEMENT.null_flavour"),
kind: other.as_str(),
direction: Direction::OpenehrToFhir,
}),
}
}
#[derive(Debug, Default)]
struct Dropped {
code: Option<CodePhrase>,
mappings: Vec<Withheld>,
reason: bool,
}
type OutSource<'mapping> = (
&'mapping OpenehrTarget,
Leaf,
&'mapping FhirTarget,
FhirKind,
);
#[cfg(test)]
mod tests {
use super::read_null_flavour;
use crate::engine::fhir::FhirKind;
use crate::engine::lens::Lens;
use crate::engine::lens::null_flavour::NullFlavourLens;
#[test]
fn a_null_flavour_pairs_only_with_an_element_that_travels_as_text() {
let flavour = NullFlavourLens
.put(&fhir_types::r4::primitives::String::from("masked"), None)
.expect("masked is in the value set");
assert!(read_null_flavour(&flavour, FhirKind::String).is_ok());
let error = read_null_flavour(&flavour, FhirKind::Coding)
.expect_err("no cell pairs a null flavour with a Coding");
assert!(error.to_string().contains("null_flavour"), "{error}");
}
}