use openehr_mapping_core::diagnostic::ModelPath;
use openehr_mapping_core::position::Located;
use crate::resolve::error::ResolveCode;
use crate::resolve::extensions::Node;
use crate::resolve::extensions::diagnostic;
use crate::resolve::program::mapping::Method;
use crate::resolve::program::port::Port;
use crate::resolve::program::target::OpenehrTarget;
use crate::resolve::compile::Compiler;
use crate::resolve::compile::Scope;
const ELEMENT: &str = "ELEMENT";
impl<'a> Compiler<'a> {
pub(super) fn ports(
&mut self,
node: &Node<'a>,
method: Method,
anchor: Option<&OpenehrTarget>,
inner: &Scope,
path: &ModelPath,
) -> Method {
let Method::Programmed { code, .. } = method else {
return method;
};
let declared = self.codes.ports(&code).unwrap_or(&[]);
let file = node.origin;
let owner = file.header().name().value();
let position = node
.mapping
.mapping_code
.as_ref()
.map_or(node.mapping.position, Located::position);
let at = path.field("mappingCode");
let mut ports = Vec::with_capacity(declared.len());
if declared.is_empty() {
return Method::Programmed { code, ports };
}
let Some(anchor) = anchor else {
self.diagnostics.push(diagnostic(
file.file(),
owner,
ResolveCode::UnanchoredFunctionPort,
position,
&at,
format!(
"`{code}` reads and writes openEHR ports, and the mapping writes no \
`with.openehr` to anchor them"
),
));
return Method::Programmed { code, ports };
};
for &name in declared {
let target = if name.is_empty() {
Some(anchor.clone())
} else {
self.openehr_target(
file.file(),
owner,
&Located::new(position, String::from(name)),
inner,
&at,
)
};
let Some(target) = target else {
continue;
};
if !target.tail().segments.is_empty() {
self.diagnostics.push(diagnostic(
file.file(),
owner,
ResolveCode::UnknownTemplateNode,
position,
&at,
format!("the port `{name}` of `{code}` names no node of the template"),
));
continue;
}
if target.occurrences().len() != anchor.occurrences().len() {
self.diagnostics.push(diagnostic(
file.file(),
owner,
ResolveCode::RepeatingFunctionPort,
position,
&at,
format!(
"the port `{name}` of `{code}` repeats below `{}`, and a port holds one \
value",
anchor.path()
),
));
continue;
}
ports.push(Port::new(name, self.port_values(&target)));
}
Method::Programmed { code, ports }
}
fn port_values(&self, target: &OpenehrTarget) -> Vec<(String, OpenehrTarget)> {
let node = target.node();
if node.rm_type() != ELEMENT {
return vec![(String::from(node.rm_type()), target.clone())];
}
node.children()
.iter()
.filter_map(|flat_id| self.template.node_by_flat_id(flat_id).ok())
.map(|child| {
let value = OpenehrTarget::new(
child.rm_path().clone(),
child.clone(),
target.tail().clone(),
target.occurrences().to_vec(),
);
(String::from(child.rm_type()), value)
})
.collect()
}
}