Struct Rule

pub struct Rule { /* private fields */ }

A single rule in an AIM structure representing a workflow component

Rules are the fundamental building blocks of AIM workflows, defining how values are computed, formatted, evaluated, or assigned. Each rule consists of:

• An identifier that uniquely names the rule
• A type definition that constrains valid values
• An expression that computes the rule’s value
• A current value (computed or assigned)
• Internal flags tracking state and category

Examples

// Create a simple rule
let rule = Rule::new(
    "temperature".to_string(),
    Typedef::Number,
    Expression::Empty,
    Value::Literal(Literal::from_number(25.0))
);

Implementations

impl Rule

pub fn new( identifier: String, typedef: Typedef, expression: Expression, value: Value, ) -> Self

Create a new Rule with the given components

Parameters

• identifier: The rule’s unique identifier
• typedef: The type definition for the rule
• expression: The expression that computes the rule’s value
• value: The initial value of the rule

Returns

A new Rule instance with appropriate flags set based on the identifier

Notes

• Automatically performs static evaluation of expressions when possible
• Sets flags based on identifier format (modifier/assignment)

pub fn new_from( input: &str, identifier: &str, typedef: &Typedef, is_assignment: bool, ) -> Self

Create a new Rule by parsing operands from a string

This constructor parses the expression/value portion of a rule definition based on the rule’s type definition and assignment status.

Parameters

• input: The string containing the rule’s operands
• identifier: The rule’s identifier
• typedef: The rule’s type definition
• is_assignment: Whether this is an assignment rule

Returns

A new Rule instance with parsed expression and value

Errors

Returns error expressions for incomplete or malformed input

pub fn is_empty(&self) -> bool

Check if the rule is completely empty (no expression and no value)

pub fn has_error(&self) -> bool

Check if the rule contains any errors

pub fn has_expression(&self) -> bool

Check if the rule has a non-empty expression

pub fn identifier(&self) -> &str

Get the rule’s identifier

pub fn ucid(&self) -> String

Get the uppercase identifier (trimming leading underscore if present)

Useful for case-insensitive comparisons and display purposes

pub fn lcid(&self) -> String

Get the lowercase identifier (trimming leading underscore if present)

Useful for case-insensitive comparisons and display purposes

pub fn set_identifier(&mut self, identifier: String)

Set a new identifier for the rule

Updates the identifier and automatically adjusts flags based on the new identifier format

pub fn is_modifier(&self) -> bool

Check if this is a modifier rule (all uppercase identifier)

pub fn is_assignment(&self) -> bool

Check if this is an assignment rule (identifier starts with underscore)

pub fn assign( &mut self, value: Value, context: &mut dyn ContextLike, ) -> Result<()>

Assign a value to this rule

Parameters

• value: The value to assign
• context: The evaluation context for resolving references

Returns

Ok(()) if assignment was successful, Err if type mismatch occurs

Notes

• For assignment rules, sets the referenced value in the context
• For other rules, directly sets the rule’s value

pub fn typedef(&self) -> &Typedef

Get the rule’s type definition

pub fn set_typedef(&mut self, typedef: Typedef)

Set a new type definition for the rule

Resets the value to empty and marks the rule as touched

pub fn expression(&self) -> &Expression

Get the rule’s expression

pub fn set_expression(&mut self, expression: Expression)

Set a new expression for the rule

Marks the rule as touched if the expression differs from the current one

pub fn value(&self) -> &Value

Get the rule’s current value

pub fn set_value(&mut self, value: Value) -> Result<()>

Set the rule’s value

Parameters

• value: The value to set

Returns

Ok(()) if the value matches the rule’s type, Err otherwise

pub fn is_format(&self) -> bool

Check if this is a format rule

pub fn is_eval(&self) -> bool

Check if this is an evaluation rule

pub fn set_pass(&mut self)

Mark an evaluation rule as passing

Only affects rules with Eval type definitions

pub fn set_fail(&mut self)

Mark an evaluation rule as failing

Only affects rules with Eval type definitions

pub fn is_node(&self) -> bool

Check if this is a node rule

pub fn get_node(&self) -> Option<Node>

Get the node from this rule if it is a node rule

Returns

Some(Node) if this is a node rule with a node value, None otherwise

pub fn touch(&mut self)

Mark the rule as touched (modified and needing saving)

pub fn save(&mut self, writer: &mut Writer)

Save the rule to a writer

Writes the complete rule definition and clears the touched flag

pub fn partial_save(&mut self, index: usize, writer: &mut Writer)

Perform a partial save of the rule

Only saves if the rule has been touched, prepending the rule index

Parameters

• index: The index of this rule in its parent structure
• writer: The writer to save to

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Rule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Display the rule’s content (expression or value) for user-facing output

impl ExpressionLike for Rule

fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Value>

Evaluate the rule’s expression or value in the given context

If the rule has an expression, evaluates it. Otherwise, evaluates the rule’s value.

Parameters

• context: The evaluation context

Returns

Ok(Value) containing the evaluated result

fn write(&self, writer: &mut Writer)

Write the rule’s complete definition to a writer

Outputs the rule in AIM format: identifier: typedef = expression @ value

fn to_sanitized(&self) -> String

Get a sanitized string representation of the rule

Removes sensitive information and produces a safe representation

fn to_formula(&self) -> String

Get the rule’s formula representation

Produces a string suitable for formula evaluation

impl PartialEq for Rule

fn eq(&self, other: &Rule) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Rule