pub mod keyword;
use std::path::Path;
use std::path::PathBuf;
use openehr_mapping_core::header::Header;
use openehr_mapping_core::header::metadata::MappingName;
use openehr_mapping_core::position::Located;
use openehr_mapping_core::position::Position;
use crate::model::ast::keyword::ConditionOperator;
use crate::model::ast::keyword::ContextScope;
use crate::model::ast::keyword::DataType;
use crate::model::ast::keyword::Direction;
use crate::model::ast::keyword::ExtensionMethod;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Condition {
pub position: Position,
pub target_root: Located<String>,
pub target_attributes: Vec<Located<String>>,
pub operator: Located<ConditionOperator>,
pub criteria: Vec<Located<String>>,
pub identifying: Option<Located<bool>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct With {
pub position: Position,
pub fhir: Option<Located<String>>,
pub openehr: Option<Located<String>>,
pub data_type: Option<Located<DataType>>,
pub value: Option<Located<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ManualPath {
pub position: Position,
pub path: Located<String>,
pub value: Located<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ManualEntry {
pub position: Position,
pub name: Located<String>,
pub fhir: Vec<ManualPath>,
pub openehr: Vec<ManualPath>,
pub fhir_condition: Option<Condition>,
pub openehr_condition: Option<Condition>,
pub value: Option<Located<String>>,
pub unidirectional: Option<Located<Direction>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LinkMapping {
pub position: Position,
pub meaning: Option<Located<String>>,
pub link_type: Option<Located<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ReferenceMapping {
pub position: Position,
pub resource_type: Located<String>,
pub mappings: Vec<Mapping>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FollowedBy {
pub position: Position,
pub mappings: Vec<Mapping>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[expect(
clippy::struct_field_names,
reason = "mappingCode is the key the FHIRconnect grammar spells"
)]
pub struct Mapping {
pub position: Position,
pub name: Located<String>,
pub extension: Option<Located<ExtensionMethod>>,
pub append_to: Option<Located<String>>,
pub with: Option<With>,
pub unidirectional: Option<Located<Direction>>,
pub manual: Vec<ManualEntry>,
pub fhir_condition: Option<Condition>,
pub openehr_condition: Option<Condition>,
pub followed_by: Option<FollowedBy>,
pub reference: Option<ReferenceMapping>,
pub slot_archetype: Option<Located<MappingName>>,
pub slot_context: Option<Located<MappingName>>,
pub mapping_code: Option<Located<String>>,
pub link: Option<LinkMapping>,
pub participations_function: Option<Located<String>>,
pub conceptmap: Option<Located<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SplitTarget {
pub position: Position,
pub create: Option<Located<String>>,
pub path: Option<Located<String>>,
pub unique: Vec<Located<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HierarchySplit {
pub position: Position,
pub fhir: Option<SplitTarget>,
pub openehr: Option<SplitTarget>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Hierarchy {
pub position: Position,
pub with: Option<With>,
pub split: Option<HierarchySplit>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Preprocessor {
pub position: Position,
pub fhir_condition: Option<Condition>,
pub openehr_condition: Option<Condition>,
pub hierarchy: Option<Hierarchy>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModelSpec {
pub position: Position,
pub system: Located<String>,
pub version: Located<String>,
pub extends: Option<Located<MappingName>>,
pub structure_definition: Option<Located<String>>,
pub conceptmap: Option<Located<String>>,
pub unidirectional: Option<Located<Direction>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModelMappingFile {
file: PathBuf,
header: Header,
spec: ModelSpec,
preprocessor: Option<Preprocessor>,
mappings: Vec<Mapping>,
}
impl ModelMappingFile {
#[must_use]
pub fn new(
file: impl Into<PathBuf>,
header: Header,
spec: ModelSpec,
preprocessor: Option<Preprocessor>,
mappings: Vec<Mapping>,
) -> Self {
Self {
file: file.into(),
header,
spec,
preprocessor,
mappings,
}
}
#[must_use]
pub fn file(&self) -> &Path {
&self.file
}
#[must_use]
pub const fn header(&self) -> &Header {
&self.header
}
#[must_use]
pub const fn spec(&self) -> &ModelSpec {
&self.spec
}
#[must_use]
pub const fn preprocessor(&self) -> Option<&Preprocessor> {
self.preprocessor.as_ref()
}
#[must_use]
pub fn mappings(&self) -> &[Mapping] {
&self.mappings
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProfileRef {
pub position: Position,
pub url: Option<Located<String>>,
pub version: Option<Located<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TemplateRef {
pub position: Position,
pub id: Option<Located<String>>,
pub sem_ver: Option<Located<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MappingContext {
pub position: Position,
pub profile: ProfileRef,
pub template: TemplateRef,
pub archetypes: Vec<Located<MappingName>>,
pub extensions: Vec<Located<MappingName>>,
pub operational: Vec<Located<MappingName>>,
pub scope: Option<Located<ContextScope>>,
pub contexts: Vec<Located<MappingName>>,
pub start: Located<MappingName>,
}
impl MappingContext {
#[must_use]
pub fn scope(&self) -> ContextScope {
self.scope
.as_ref()
.map_or(ContextScope::Root, |scope| *scope.value())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContextMappingFile {
file: PathBuf,
header: Header,
context: MappingContext,
}
impl ContextMappingFile {
#[must_use]
pub fn new(file: impl Into<PathBuf>, header: Header, context: MappingContext) -> Self {
Self {
file: file.into(),
header,
context,
}
}
#[must_use]
pub fn file(&self) -> &Path {
&self.file
}
#[must_use]
pub const fn header(&self) -> &Header {
&self.header
}
#[must_use]
pub const fn context(&self) -> &MappingContext {
&self.context
}
}
#[must_use]
pub fn walk(mappings: &[Mapping]) -> Vec<&Mapping> {
let mut found = Vec::new();
let mut stack: Vec<&Mapping> = mappings.iter().rev().collect();
while let Some(mapping) = stack.pop() {
found.push(mapping);
let children = mapping
.reference
.as_ref()
.map(|reference| reference.mappings.as_slice())
.into_iter()
.chain(
mapping
.followed_by
.as_ref()
.map(|followed| followed.mappings.as_slice()),
);
for child in children.flatten().rev() {
stack.push(child);
}
}
found
}