Struct IncrementalEngine 

pub struct IncrementalEngine { /* private fields */ }

Incremental Propagation Engine Only re-evaluates rules affected by changed facts

Implementations

impl IncrementalEngine

pub fn new() -> Self

Create new incremental engine

pub fn add_rule(&mut self, rule: TypedReteUlRule, depends_on: Vec<String>)

Add rule and register its dependencies

pub fn insert(&mut self, fact_type: String, data: TypedFacts) -> FactHandle

Insert fact into working memory

pub fn update(&mut self, handle: FactHandle, data: TypedFacts) -> Result<()>

Update fact in working memory

pub fn retract(&mut self, handle: FactHandle) -> Result<()>

Retract fact from working memory

pub fn insert_explicit( &mut self, fact_type: String, data: TypedFacts, ) -> FactHandle

Insert a fact with explicit assertion (user provided) This fact will NOT be auto-retracted by TMS

pub fn insert_logical( &mut self, fact_type: String, data: TypedFacts, source_rule: String, premise_handles: Vec<FactHandle>, ) -> FactHandle

Insert a fact with logical assertion (derived by a rule) This fact WILL be auto-retracted if its premises become invalid

Arguments

• fact_type - Type of the fact (e.g., “Customer”)
• data - The fact data
• source_rule - Name of the rule deriving this fact
• premise_handles - Handles of facts matched in the rule’s WHEN clause

pub fn resolve_premise_keys(&self, premise_keys: Vec<String>) -> Vec<FactHandle>

Resolve premise keys (format: “Type.field=value” or “Type.field=”) to a Vec by looking up facts of the given type and matching the field value when provided. If value is empty, return the most recent handle for that type (if any).

pub fn tms(&self) -> &TruthMaintenanceSystem

Get TMS reference

pub fn tms_mut(&mut self) -> &mut TruthMaintenanceSystem

Get mutable TMS reference

pub fn fire_all(&mut self) -> Vec<String>

Fire all pending activations

pub fn working_memory(&self) -> &WorkingMemory

Get working memory

pub fn working_memory_mut(&mut self) -> &mut WorkingMemory

Get mutable working memory

pub fn agenda(&self) -> &AdvancedAgenda

Get agenda

pub fn agenda_mut(&mut self) -> &mut AdvancedAgenda

Get mutable agenda

pub fn set_conflict_resolution_strategy( &mut self, strategy: ConflictResolutionStrategy, )

Set conflict resolution strategy

Controls how conflicting rules in the agenda are ordered. Available strategies: Salience (default), LEX, MEA, Depth, Breadth, Simplicity, Complexity, Random

pub fn conflict_resolution_strategy(&self) -> ConflictResolutionStrategy

Get current conflict resolution strategy

pub fn stats(&self) -> IncrementalEngineStats

Get statistics

pub fn reset(&mut self)

Clear fired flags and reset agenda

pub fn templates(&self) -> &TemplateRegistry

Get template registry

pub fn templates_mut(&mut self) -> &mut TemplateRegistry

Get mutable template registry

pub fn register_function<F>(&mut self, name: &str, func: F)

where F: Fn(&[FactValue], &TypedFacts) -> Result<FactValue> + Send + Sync + 'static,

Register a custom function for Test CE support

Example

use rust_rule_engine::rete::{IncrementalEngine, FactValue};

let mut engine = IncrementalEngine::new();
engine.register_function(
    "is_valid_email",
    |args, _facts| {
        if let Some(FactValue::String(email)) = args.first() {
            Ok(FactValue::Boolean(email.contains('@')))
        } else {
            Ok(FactValue::Boolean(false))
        }
    }
);

pub fn get_function(&self, name: &str) -> Option<&ReteCustomFunction>

Get a custom function by name (for Test CE evaluation)

pub fn globals(&self) -> &GlobalsRegistry

Get global variables registry

pub fn globals_mut(&mut self) -> &mut GlobalsRegistry

Get mutable global variables registry

pub fn deffacts(&self) -> &DeffactsRegistry

Get deffacts registry

pub fn deffacts_mut(&mut self) -> &mut DeffactsRegistry

Get mutable deffacts registry

pub fn load_deffacts(&mut self) -> Vec<FactHandle>

Load all registered deffacts into working memory Returns handles of all inserted facts

pub fn load_deffacts_by_name(&mut self, name: &str) -> Result<Vec<FactHandle>>

Load a specific deffacts set by name Returns handles of inserted facts or error if deffacts not found

pub fn reset_with_deffacts(&mut self) -> Vec<FactHandle>

Reset engine and reload all deffacts (similar to CLIPS reset) Clears working memory and agenda, then loads all deffacts

pub fn insert_with_template( &mut self, template_name: &str, data: TypedFacts, ) -> Result<FactHandle>

Insert a typed fact with template validation

Trait Implementations

impl Default for IncrementalEngine

fn default() -> Self

Returns the “default value” for a type.