use core::fmt;
use crate::model::ast::keyword::Direction;
use crate::resolve::program::condition::Condition;
use crate::resolve::program::condition::render_condition;
use crate::resolve::program::target::Target;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ManualValue {
Literal(String),
Context(String),
}
impl fmt::Display for ManualValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Self::Literal(ref text) => f.write_str(text),
Self::Context(ref name) => write!(f, "$context.{name}"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ManualPath {
target: Target,
value: ManualValue,
}
impl ManualPath {
#[must_use]
pub const fn new(target: Target, value: ManualValue) -> Self {
Self { target, value }
}
#[must_use]
pub const fn target(&self) -> &Target {
&self.target
}
#[must_use]
pub const fn value(&self) -> &ManualValue {
&self.value
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Manual {
name: String,
fhir: Vec<ManualPath>,
openehr: Vec<ManualPath>,
fhir_condition: Option<Condition>,
openehr_condition: Option<Condition>,
value: Option<String>,
direction: Option<Direction>,
}
impl Manual {
#[must_use]
pub const fn new(
name: String,
fhir: Vec<ManualPath>,
openehr: Vec<ManualPath>,
fhir_condition: Option<Condition>,
openehr_condition: Option<Condition>,
value: Option<String>,
direction: Option<Direction>,
) -> Self {
Self {
name,
fhir,
openehr,
fhir_condition,
openehr_condition,
value,
direction,
}
}
#[must_use]
pub fn name(&self) -> &str {
&self.name
}
#[must_use]
pub fn fhir(&self) -> &[ManualPath] {
&self.fhir
}
#[must_use]
pub fn openehr(&self) -> &[ManualPath] {
&self.openehr
}
#[must_use]
pub const fn fhir_condition(&self) -> Option<&Condition> {
self.fhir_condition.as_ref()
}
#[must_use]
pub const fn openehr_condition(&self) -> Option<&Condition> {
self.openehr_condition.as_ref()
}
#[must_use]
pub fn value(&self) -> Option<&str> {
self.value.as_deref()
}
#[must_use]
pub const fn direction(&self) -> Option<Direction> {
self.direction
}
}
pub(super) fn render_manual(f: &mut fmt::Formatter<'_>, pad: &str, manual: &Manual) -> fmt::Result {
writeln!(f, "{pad}manual {}", manual.name())?;
let inner = format!("{pad} ");
if let Some(direction) = manual.direction() {
writeln!(f, "{inner}unidirectional {direction}")?;
}
if let Some(value) = manual.value() {
writeln!(f, "{inner}value {value}")?;
}
for path in manual.fhir().iter().chain(manual.openehr()) {
writeln!(f, "{inner}{} = {}", path.target(), path.value())?;
}
for (label, condition) in [
("fhirCondition", manual.fhir_condition()),
("openehrCondition", manual.openehr_condition()),
] {
if let Some(condition) = condition {
render_condition(f, &inner, label, condition)?;
}
}
Ok(())
}