Enum ConditionGroup 

pub enum ConditionGroup {
    Single(Condition),
    Compound {
        left: Box<ConditionGroup>,
        operator: LogicalOperator,
        right: Box<ConditionGroup>,
    },
    Not(Box<ConditionGroup>),
    Exists(Box<ConditionGroup>),
    Forall(Box<ConditionGroup>),
    Accumulate {
        result_var: String,
        source_pattern: String,
        extract_field: String,
        source_conditions: Vec<String>,
        function: String,
        function_arg: String,
    },
}

Group of conditions with logical operators

Variants

Single(Condition)

A single condition

Compound

A compound condition with two sub-conditions and a logical operator

Fields

left: Box<ConditionGroup>

The left side condition

operator: LogicalOperator

The logical operator (AND, OR)

right: Box<ConditionGroup>

The right side condition

Not(Box<ConditionGroup>)

A negated condition group

Exists(Box<ConditionGroup>)

Pattern matching: check if at least one fact matches the condition

Forall(Box<ConditionGroup>)

Pattern matching: check if all facts of the target type match the condition

Accumulate

Accumulate pattern: aggregate values from matching facts Example: accumulate(Order($amount: amount, status == “completed”), sum($amount))

Fields

result_var: String

Variable to bind the result to (e.g., “$total”)

source_pattern: String

Source pattern to match facts (e.g., “Order”)

extract_field: String

Field to extract from matching facts (e.g., “$amount: amount”)

source_conditions: Vec<String>

Conditions on the source pattern

function: String

Accumulate function to apply (sum, avg, count, min, max)

function_arg: String

Variable passed to function (e.g., “$amount” in “sum($amount)”)

Implementations

impl ConditionGroup

pub fn single(condition: Condition) -> Self

Create a single condition group

pub fn and(left: ConditionGroup, right: ConditionGroup) -> Self

Create a compound condition using logical AND operator

pub fn or(left: ConditionGroup, right: ConditionGroup) -> Self

Create a compound condition using logical OR operator

pub fn not(condition: ConditionGroup) -> Self

Create a negated condition using logical NOT operator

pub fn exists(condition: ConditionGroup) -> Self

Create an exists condition - checks if at least one fact matches

pub fn forall(condition: ConditionGroup) -> Self

Create a forall condition - checks if all facts of target type match

pub fn accumulate( result_var: String, source_pattern: String, extract_field: String, source_conditions: Vec<String>, function: String, function_arg: String, ) -> Self

Create an accumulate condition - aggregates values from matching facts

pub fn evaluate(&self, facts: &HashMap<String, Value>) -> bool

Evaluate this condition group against facts

pub fn evaluate_with_facts(&self, facts: &Facts) -> bool

Evaluate this condition group against Facts (supports pattern matching)

Trait Implementations

impl Clone for ConditionGroup

fn clone(&self) -> ConditionGroup

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConditionGroup

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

Formats the value using the given formatter.