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 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 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.