Struct RustRuleEngine 

pub struct RustRuleEngine { /* private fields */ }

Rust Rule Engine - High-performance rule execution engine

Implementations

impl RustRuleEngine

pub fn new(knowledge_base: KnowledgeBase) -> Self

Create a new RustRuleEngine with default configuration

pub fn with_config(knowledge_base: KnowledgeBase, config: EngineConfig) -> Self

Create a new RustRuleEngine with custom configuration

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

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

Register a custom function

pub fn register_action_handler<F>(&mut self, action_type: &str, handler: F)

where F: Fn(&HashMap<String, Value>, &Facts) -> Result<()> + Send + Sync + 'static,

Register a custom action handler

pub fn enable_analytics(&mut self, analytics: RuleAnalytics)

Enable analytics with custom configuration

pub fn reset_no_loop_tracking(&mut self)

Reset global no-loop tracking (useful for testing or when facts change significantly)

pub fn disable_analytics(&mut self)

Disable analytics

pub fn analytics(&self) -> Option<&RuleAnalytics>

Get reference to analytics data

pub fn has_function(&self, name: &str) -> bool

Check if a custom function is registered

pub fn has_action_handler(&self, action_type: &str) -> bool

Check if a custom action handler is registered

pub fn knowledge_base(&self) -> &KnowledgeBase

Get reference to the knowledge base

pub fn knowledge_base_mut(&mut self) -> &mut KnowledgeBase

Get mutable reference to the knowledge base

pub fn set_agenda_focus(&mut self, group: &str)

Set focus to a specific agenda group

pub fn get_active_agenda_group(&self) -> &str

Get the currently active agenda group

pub fn pop_agenda_focus(&mut self) -> Option<String>

Pop the agenda focus stack

pub fn clear_agenda_focus(&mut self)

Clear all agenda focus and return to MAIN

pub fn get_agenda_groups(&self) -> Vec<String>

Get all agenda groups that have rules

pub fn get_activation_groups(&self) -> Vec<String>

Get all activation groups that have rules

pub fn execute(&mut self, facts: &Facts) -> Result<GruleExecutionResult>

Execute all rules in the knowledge base against the given facts

pub fn execute_at_time( &mut self, facts: &Facts, timestamp: DateTime<Utc>, ) -> Result<GruleExecutionResult>

Execute all rules at a specific timestamp (for date-effective/expires testing)