Struct ChainRule 

pub struct ChainRule { /* private fields */ }

ChainRule represents a rule that can have at most one child. When executed, it will run its child rule if the evaluation succeeds.

Example

use dredd_rs::rule::*;

let mut rule = ChainRule::new();
rule.set_eval_fn(|context| {
    context.get_bool("should_execute")
});
rule.set_execute_fn(|context| {
    context.set_bool("executed", true);
    Ok(())
});

let mut context = RuleContext::new();
context.set_bool("should_execute", true);

let result = rule.fire(&mut context).unwrap();
assert!(result);

Implementations

impl ChainRule

pub fn new() -> Self

Create a new ChainRule

pub fn builder() -> ChainRuleBuilder

Create a builder for ChainRule

pub fn set_eval_fn<F>(&mut self, f: F) -> &mut Self

where F: Fn(&RuleContext) -> RuleResult<bool> + 'static,

Set the evaluation function

pub fn set_pre_execute_fn<F>(&mut self, f: F) -> &mut Self

where F: Fn(&mut RuleContext) -> RuleResult<()> + 'static,

Set the pre-execution function

pub fn set_execute_fn<F>(&mut self, f: F) -> &mut Self

where F: Fn(&mut RuleContext) -> RuleResult<()> + 'static,

Set the execution function

pub fn set_post_execute_fn<F>(&mut self, f: F) -> &mut Self

where F: Fn(&mut RuleContext) -> RuleResult<()> + 'static,

Set the post-execution function

pub fn set_child(&mut self, child: Box<dyn Rule>) -> RuleResult<&mut Self>

Add a child rule (ChainRule can only have one child)

Trait Implementations

impl Default for ChainRule

fn default() -> Self

Returns the “default value” for a type.

impl Rule for ChainRule

fn fire(&mut self, context: &mut RuleContext) -> RuleResult<bool>

Custom fire implementation for ChainRule that handles single child execution

fn evaluate(&self, context: &RuleContext) -> RuleResult<bool>

Evaluate if this rule should execute

fn execute(&mut self, context: &mut RuleContext) -> RuleResult<()>

Execute the rule with proper error handling

fn children(&self) -> &[Box<dyn Rule>]

Get immutable reference to children

fn children_mut(&mut self) -> &mut Vec<Box<dyn Rule>>

Get mutable reference to children

fn add_child(&mut self, child: Box<dyn Rule>) -> RuleResult<()>

Add a child rule

fn add_children(&mut self, children: Vec<Box<dyn Rule>>) -> RuleResult<()>

Add multiple child rules