Struct RustRuleEngine 

pub struct RustRuleEngine { /* private fields */ }

Rust Rule Engine - High-performance rule execution engine

Implementations

impl RustRuleEngine

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

where F: FnMut(&str, &Facts),

Execute all rules and call callback when a rule is fired

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 set_debug_mode(&mut self, enabled: bool)

Enable debug mode for detailed execution logging

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 get_ready_tasks(&mut self) -> Vec<ScheduledTask>

Get ready scheduled tasks

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

Execute scheduled tasks that are ready

pub fn activate_agenda_group(&mut self, group: String)

Activate agenda group

pub fn knowledge_base(&self) -> &KnowledgeBase

Get the knowledge base

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

Get mutable reference to 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 start_workflow(&mut self, workflow_name: Option<String>) -> String

Start a new workflow

pub fn get_workflow_stats(&self) -> WorkflowStats

Get workflow statistics

pub fn get_workflow(&self, workflow_id: &str) -> Option<&WorkflowState>

Get workflow state by ID

pub fn cleanup_completed_workflows(&mut self, older_than: Duration)

Clean up completed workflows

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

Execute workflow step by activating specific agenda group

pub fn execute_workflow( &mut self, agenda_groups: Vec<&str>, facts: &Facts, ) -> Result<WorkflowResult>

Execute a complete workflow by processing agenda groups sequentially

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)

pub fn load_plugin(&mut self, plugin: Arc<dyn RulePlugin>) -> Result<()>

Load a plugin into the engine

pub fn unload_plugin(&mut self, name: &str) -> Result<()>

Unload a plugin from the engine

pub fn hot_reload_plugin( &mut self, name: &str, new_plugin: Arc<dyn RulePlugin>, ) -> Result<()>

Hot reload a plugin

pub fn get_plugin_info(&self, name: &str) -> Option<&PluginMetadata>

Get plugin information

pub fn list_plugins(&self) -> Vec<PluginInfo>

List all loaded plugins

pub fn get_plugin_stats(&self) -> PluginStats

Get plugin statistics

pub fn plugin_health_check(&mut self) -> HashMap<String, PluginHealth>

Check health of all plugins

pub fn configure_plugins(&mut self, config: PluginConfig)

Configure plugin manager