Struct Engine 

pub struct Engine<Ctx: MaybeSync + ?Sized + 'static> { /* private fields */ }

Rules engine for registering fetchers/operators and parsing rules.

Type Parameters

• Ctx: The context type that rules will be evaluated against

Example

struct User {
    name: String,
    age: u32,
    roles: Vec<String>,
}

let mut engine = Engine::new();

engine.register_fetcher("name", |user: &User, _args| {
    Ok(Value::from(&user.name))
});

engine.register_fetcher("age", |user: &User, _args| {
    Ok(Value::from(user.age))
});

engine.register_fetcher("has_role", |user: &User, args| {
    let role = args.first().ok_or("Role name required")?;
    Ok(Value::from(user.roles.contains(&role)))
});

let rule = engine.compile_rule(&json!([
    {"age": {">=": 18}},
    {"has_role(admin)": true}
])).unwrap();

Implementations

impl<Ctx: MaybeSync + ?Sized> Engine<Ctx>

pub fn new() -> Self

Creates a new rules engine instance.

pub fn register_fetcher<F>(&mut self, name: &str, func: F) -> &mut Fetcher<Ctx>

where F: for<'a> Fn(&'a Ctx, &[String]) -> StdResult<Value<'a>, Box<dyn StdError>> + MaybeSend + MaybeSync + 'static,

Registers a synchronous fetcher with its name and function, using the default matcher.

A fetcher is a function that extracts values from the context type. The fetcher name is used in rule definitions to reference this fetcher. By default, the DefaultMatcher is used, which supports basic equality and comparison operations.

Returns

A mutable reference to the created Fetcher, allowing you to customize it (e.g., change the matcher)

pub fn register_async_fetcher<F>( &mut self, name: &str, func: F, ) -> &mut Fetcher<Ctx>

where F: for<'a> Fn(&'a Ctx, Arc<[String]>) -> BoxFuture<'a, StdResult<Value<'a>, Box<dyn StdError>>> + MaybeSend + MaybeSync + 'static,

Registers an async fetcher with its name and function, using the default matcher.

See Self::register_fetcher for more details.

pub fn register_operator<O>(&mut self, name: &str, op: O)

where O: ToOperator<Ctx> + 'static,

Registers a custom operator

pub fn compile_rule(&self, value: &JsonValue) -> Result<Rule<Ctx>, Error>

Compiles a JSON value into a Rule::All using the registered fetchers and operators.

pub fn validate_rule<'a>( &self, value: &'a JsonValue, ) -> StdResult<(), ValidationError<'a>>

Available on crate feature validation only.

Validates a JSON rule against dynamically generated JSON Schema of this engine.

pub fn json_schema(&self) -> JsonValue

Builds a JSON Schema for rules, including dynamic properties.

Trait Implementations

impl<Ctx: MaybeSync + ?Sized> Clone for Engine<Ctx>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Ctx: MaybeSync + ?Sized> Default for Engine<Ctx>

fn default() -> Self

Returns the “default value” for a type.