Struct CompiledLogic 

pub struct CompiledLogic {
    pub root: CompiledNode,
}

Compiled logic that can be evaluated multiple times across different data.

CompiledLogic represents a pre-processed JSONLogic expression that has been optimized for repeated evaluation. It’s thread-safe and can be shared across threads using Arc.

Performance Benefits

• Parse once, evaluate many: Avoid repeated JSON parsing
• Static evaluation: Constant expressions are pre-computed
• OpCode dispatch: Built-in operators use fast enum dispatch
• Thread-safe sharing: Use Arc to share across threads

Example

use datalogic_rs::DataLogic;
use serde_json::json;
use std::sync::Arc;

let engine = DataLogic::new();
let logic = json!({">": [{"var": "score"}, 90]});
let compiled = engine.compile(&logic).unwrap(); // Returns Arc<CompiledLogic>

// Can be shared across threads
let compiled_clone = Arc::clone(&compiled);
std::thread::spawn(move || {
    let data = json!({"score": 95});
    let result = engine.evaluate_owned(&compiled_clone, data);
});

Fields

root: CompiledNode

The root node of the compiled logic tree

Implementations

impl CompiledLogic

pub fn compile(logic: &Value) -> Result<Self>

Compiles a JSON value into a compiled logic structure.

This method performs basic compilation without static evaluation. For optimal performance, use compile_with_static_eval instead.

Arguments

• logic - The JSON logic expression to compile

Returns

A compiled logic structure, or an error if compilation fails.

pub fn compile_for_trace( logic: &Value, preserve_structure: bool, ) -> Result<Self>

Compiles for tracing without static evaluation.

This method compiles the logic without performing static evaluation, ensuring that all operators remain in the tree for step-by-step debugging. Use this when you need to trace execution through operators that would otherwise be pre-evaluated at compile time.

Arguments

• logic - The JSON logic expression to compile
• preserve_structure - Whether to preserve unknown object structure

Returns

A compiled logic structure without static optimizations.

pub fn compile_with_static_eval( logic: &Value, engine: &DataLogic, ) -> Result<Self>

Compiles with static evaluation using the provided engine.

This method performs optimizations including:

• Static evaluation of constant expressions
• OpCode assignment for built-in operators
• Structure preservation based on engine settings

Arguments

• logic - The JSON logic expression to compile
• engine - The DataLogic engine for static evaluation

Returns

An optimized compiled logic structure, or an error if compilation fails.

impl CompiledLogic

pub fn new(root: CompiledNode) -> Self

Creates a new compiled logic from a root node.

Arguments

• root - The root node of the compiled logic tree

pub fn is_static(&self) -> bool

Check if this compiled logic is static (can be evaluated without context)

Trait Implementations

impl Clone for CompiledLogic

fn clone(&self) -> CompiledLogic

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompiledLogic

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.