use core::fmt;
use crate::model::ast::keyword::ConditionOperator;
use crate::model::ast::keyword::Direction;
use crate::resolve::program::target::Attachment;
use crate::resolve::program::target::Target;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConditionParts {
pub direction: Direction,
pub target: Target,
pub attributes: Vec<Target>,
pub operator: ConditionOperator,
pub criteria: Vec<String>,
pub identifying: bool,
pub attachment: Attachment,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Condition {
direction: Direction,
target: Target,
attributes: Vec<Target>,
operator: ConditionOperator,
criteria: Vec<String>,
identifying: bool,
attachment: Attachment,
}
impl Condition {
#[must_use]
pub fn new(parts: ConditionParts) -> Self {
Self {
direction: parts.direction,
target: parts.target,
attributes: parts.attributes,
operator: parts.operator,
criteria: parts.criteria,
identifying: parts.identifying,
attachment: parts.attachment,
}
}
#[must_use]
pub const fn attachment(&self) -> Attachment {
self.attachment
}
#[must_use]
pub const fn direction(&self) -> Direction {
self.direction
}
#[must_use]
pub const fn target(&self) -> &Target {
&self.target
}
#[must_use]
pub fn attributes(&self) -> &[Target] {
&self.attributes
}
#[must_use]
pub const fn operator(&self) -> ConditionOperator {
self.operator
}
#[must_use]
pub fn criteria(&self) -> &[String] {
&self.criteria
}
#[must_use]
pub const fn identifying(&self) -> bool {
self.identifying
}
}
pub(super) fn render_condition(
f: &mut fmt::Formatter<'_>,
pad: &str,
label: &str,
condition: &Condition,
) -> fmt::Result {
writeln!(
f,
"{pad}{label} {} {} on {} ({})",
condition.operator(),
render_criteria(condition.criteria()),
condition.target(),
condition.attachment()
)?;
for attribute in condition.attributes() {
writeln!(f, "{pad} attribute {attribute}")?;
}
Ok(())
}
fn render_criteria(criteria: &[String]) -> String {
if criteria.is_empty() {
return String::from("[]");
}
format!("[{}]", criteria.join(", "))
}