use crate::resolve::derive;
use openehr_rm::v1_2::model;
use openehr_rm::v1_2::model::Container;
use openehr_rm::v1_2::paths::RmPath;
use openehr_rm::v1_2::typing::RmType;
use openehr_rm::v1_2::typing::base_name;
use super::tail_walk;
use super::tail_walk::concrete_forms;
use super::{ENTRY_TIMES, FAMILIES, PARTY_ROOTS};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Carried {
Text,
Real,
Integer,
Boolean,
Value,
Family,
EntryTime,
}
#[must_use]
pub fn carried(rm_type: &str, tail: &[&str]) -> Option<(&'static str, Carried)> {
let wanted = tail.join("/");
let class = base_name(rm_type);
if let Some(&(owner, _)) = ENTRY_TIMES
.iter()
.find(|&&(owner, path)| path == wanted && model::is_a(class, owner))
{
return Some((owner, Carried::EntryTime));
}
if let Some(&(owner, _)) = FAMILIES
.iter()
.find(|&&(owner, path)| path == wanted && model::is_a(class, owner))
{
return Some((owner, Carried::Family));
}
if let Some(&(owner, _)) = PARTY_ROOTS
.iter()
.find(|&&(owner, path)| path == wanted && class == owner)
{
return Some((owner, Carried::Value));
}
let walked = walk(rm_type, tail)?;
if walked.container != Container::None {
return None;
}
Some((walked.owner, held(&walked.declared)?))
}
#[must_use]
pub fn list_steps(rm_type: &str, tail: &[&str]) -> Option<Vec<usize>> {
walk(rm_type, tail).map(|walked| walked.lists)
}
struct Walked {
owner: &'static str,
container: Container,
declared: String,
lists: Vec<usize>,
}
fn walk(rm_type: &str, tail: &[&str]) -> Option<Walked> {
let class = rm_type.parse::<RmType>().ok()?;
if model::is_a(class.name(), derive::STRUCTURAL) {
return None;
}
let owner = owner_of(class.name(), tail.first()?)?;
let path = tail.join("/").parse::<RmPath>().ok()?;
let steps = tail_walk::steps(rm_type, &path).ok().flatten()?;
let mut lists = Vec::new();
for (position, step) in steps.iter().enumerate() {
match step.container() {
Container::None => {}
Container::List => lists.push(position),
Container::Set | Container::Hash => return None,
}
}
let last = steps.last()?;
Some(Walked {
owner,
container: last.container(),
declared: String::from(last.item().name()),
lists,
})
}
fn owner_of(rm_type: &str, attribute: &str) -> Option<&'static str> {
let declaring: Vec<&'static str> = concrete_forms(rm_type)
.into_iter()
.filter(|form| model::class(form).is_some_and(|class| !class.is_abstract))
.filter(|form| model::attribute(form, attribute).is_some())
.collect();
declaring.iter().copied().find(|&form| {
!declaring
.iter()
.any(|&other| other != form && model::is_a(form, other))
})
}
fn held(declared_type: &str) -> Option<Carried> {
match declared_type {
"String" | "Character" => Some(Carried::Text),
"Real" => Some(Carried::Real),
"Integer" | "Integer64" => Some(Carried::Integer),
"Boolean" => Some(Carried::Boolean),
other => model::class(other).map(|_| Carried::Value),
}
}
#[cfg(test)]
mod tests {
use super::{Carried, carried, list_steps};
#[test]
fn a_tail_reaches_every_attribute_the_model_gives_the_class() {
assert_eq!(
carried("DV_TEXT", &["hyperlink", "value"]),
Some(("DV_TEXT", Carried::Text))
);
assert_eq!(
carried("DV_TEXT", &["language"]),
Some(("DV_TEXT", Carried::Value))
);
assert_eq!(
carried("DV_DATE_TIME", &["normal_status", "code_string"]),
Some(("DV_DATE_TIME", Carried::Text))
);
assert_eq!(
carried("DV_PROPORTION", &["numerator"]),
Some(("DV_PROPORTION", Carried::Real))
);
assert_eq!(
carried("DV_INTERVAL", &["lower_included"]),
Some(("DV_INTERVAL", Carried::Boolean))
);
}
#[test]
fn a_tail_below_a_generic_interval_reaches_its_parameter() {
assert_eq!(
carried("DV_INTERVAL<DV_QUANTITY>", &["lower"]),
Some(("DV_INTERVAL", Carried::Value))
);
assert_eq!(
carried("DV_INTERVAL<DV_QUANTITY>", &["upper", "magnitude"]),
Some(("DV_INTERVAL", Carried::Real))
);
assert_eq!(
carried("DV_INTERVAL<DV_COUNT>", &["lower", "magnitude"]),
Some(("DV_INTERVAL", Carried::Integer))
);
assert_eq!(
carried("DV_INTERVAL<DV_QUANTITY>", &["lower_included"]),
Some(("DV_INTERVAL", Carried::Boolean))
);
}
#[test]
fn a_tail_the_interval_parameter_does_not_carry_is_not_carried() {
assert_eq!(
carried("DV_INTERVAL<DV_QUANTITY>", &["lower", "numerator"]),
None
);
assert_eq!(carried("DV_INTERVAL<DV_QUANTITY>", &["middle"]), None);
}
#[test]
fn a_tail_only_a_subtype_declares_writes_the_subtype() {
assert_eq!(
carried("DV_TEXT", &["defining_code", "code_string"]),
Some(("DV_CODED_TEXT", Carried::Text))
);
assert_eq!(
carried("PARTY_PROXY", &["name"]),
Some(("PARTY_IDENTIFIED", Carried::Text))
);
}
#[test]
fn a_tail_that_ends_on_a_list_or_below_a_structure_is_not_carried() {
assert_eq!(carried("DV_TEXT", &["mappings"]), None);
assert_eq!(carried("DV_QUANTITY", &["other_reference_ranges"]), None);
assert_eq!(carried("EVALUATION", &["other_participations"]), None);
assert_eq!(carried("DV_TEXT", &["no_such_attribute"]), None);
}
#[test]
fn a_tail_through_a_list_reaches_the_attributes_of_one_element() {
assert_eq!(
carried("DV_TEXT", &["mappings", "match"]),
Some(("DV_TEXT", Carried::Text))
);
assert_eq!(
carried("DV_TEXT", &["mappings", "target", "code_string"]),
Some(("DV_TEXT", Carried::Text))
);
assert_eq!(
carried("DV_QUANTITY", &["other_reference_ranges", "meaning"]),
Some(("DV_QUANTITY", Carried::Value))
);
assert_eq!(
carried("DV_QUANTITY", &["other_reference_ranges", "range", "upper"]),
Some(("DV_QUANTITY", Carried::Value))
);
}
#[test]
fn each_list_a_tail_steps_through_is_named_by_its_place_in_the_tail() {
assert_eq!(list_steps("DV_TEXT", &["mappings"]), Some(vec![0]));
assert_eq!(
list_steps("DV_TEXT", &["mappings", "target", "code_string"]),
Some(vec![0])
);
assert_eq!(
list_steps("DV_QUANTITY", &["other_reference_ranges", "range", "lower"]),
Some(vec![0])
);
assert_eq!(
list_steps("DV_QUANTITY", &["normal_range", "upper"]),
Some(Vec::new())
);
assert_eq!(list_steps("EVALUATION", &["other_participations"]), None);
}
}