Struct JSONEval 

pub struct JSONEval {

    pub schema: Arc<Value>,
    pub engine: Arc<RLogic>,
    pub evaluations: Arc<IndexMap<String, LogicId>>,
    pub tables: Arc<IndexMap<String, Value>>,
    pub table_metadata: Arc<IndexMap<String, TableMetadata>>,
    pub dependencies: Arc<IndexMap<String, IndexSet<String>>>,
    pub sorted_evaluations: Arc<Vec<Vec<String>>>,
    pub dependents_evaluations: Arc<IndexMap<String, Vec<DependentItem>>>,
    pub rules_evaluations: Arc<Vec<String>>,
    pub fields_with_rules: Arc<Vec<String>>,
    pub others_evaluations: Arc<Vec<String>>,
    pub value_evaluations: Arc<Vec<String>>,
    pub layout_paths: Arc<Vec<String>>,
    pub options_templates: Arc<Vec<(String, String, String)>>,
    pub subforms: IndexMap<String, Box<JSONEval>>,
    pub reffed_by: Arc<IndexMap<String, Vec<String>>>,
    pub conditional_hidden_fields: Arc<Vec<String>>,
    pub conditional_readonly_fields: Arc<Vec<String>>,
    pub context: Value,
    pub data: Value,
    pub evaluated_schema: Value,
    pub eval_data: EvalData,
    pub eval_cache: EvalCache,
    pub cache_enabled: bool,
    /* private fields */
}

Fields

schema: Arc<Value>

engine: Arc<RLogic>

evaluations: Arc<IndexMap<String, LogicId>>

Zero-copy Arc-wrapped collections (shared from ParsedSchema)

tables: Arc<IndexMap<String, Value>>

table_metadata: Arc<IndexMap<String, TableMetadata>>

Pre-compiled table metadata (computed at parse time for zero-copy evaluation)

dependencies: Arc<IndexMap<String, IndexSet<String>>>

sorted_evaluations: Arc<Vec<Vec<String>>>

Evaluations grouped into parallel-executable batches Each inner Vec contains evaluations that can run concurrently

dependents_evaluations: Arc<IndexMap<String, Vec<DependentItem>>>

Evaluations categorized for result handling Dependents: map from source field to list of dependent items

rules_evaluations: Arc<Vec<String>>

Rules: evaluations with “/rules/” in path

fields_with_rules: Arc<Vec<String>>

Fields with rules: dotted paths of all fields that have rules (for efficient validation)

others_evaluations: Arc<Vec<String>>

Others: all other evaluations not in sorted_evaluations (for evaluated_schema output)

value_evaluations: Arc<Vec<String>>

Value: evaluations ending with “.value” in path

layout_paths: Arc<Vec<String>>

Cached layout paths (collected at parse time)

options_templates: Arc<Vec<(String, String, String)>>

Options URL templates (url_path, template_str, params_path) collected at parse time

subforms: IndexMap<String, Box<JSONEval>>

Subforms: isolated JSONEval instances for array fields with items Key is the schema path (e.g., “#/riders”), value is the sub-JSONEval

reffed_by: Arc<IndexMap<String, Vec<String>>>

Cached reference to parsed schema mappings (reffed_by)

conditional_hidden_fields: Arc<Vec<String>>

Cached paths of fields that have hidden conditions

conditional_readonly_fields: Arc<Vec<String>>

Cached paths of fields that have disabled conditions and value property

context: Value

data: Value

evaluated_schema: Value

eval_data: EvalData

eval_cache: EvalCache

Evaluation cache with content-based hashing and zero-copy storage

cache_enabled: bool

Flag to enable/disable evaluation caching Set to false for web API usage where each request creates a new JSONEval instance

Implementations

impl JSONEval

pub fn should_cache_dependency(&self, dep_path: &str) -> bool

Check if a dependency should be part of the cache key

pub fn purge_cache_for_changed_data_with_comparison( &self, changed_paths: &[String], old_data: &Value, new_data: &Value, )

Purge cache entries affected by changed data paths, comparing old and new values

pub fn purge_cache_for_changed_data(&self, changed_paths: &[String])

Purge cache entries affected by changed data paths

pub fn purge_cache_for_context_change(&self)

Purge cache entries affected by context changes

pub fn cache_stats(&self) -> CacheStats

Get cache statistics

Examples found in repository

examples/cache_disable.rs (line 51)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

examples/benchmark.rs (line 344)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("benchmark");
    
    let mut iterations = 1usize;
    let mut scenario_filter: Option<String> = None;
    let mut show_cpu_info = false;
    let mut use_parsed_schema = false;
    let mut concurrent_count: Option<usize> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--cpu-info" {
            show_cpu_info = true;
        } else if arg == "--parsed" {
            use_parsed_schema = true;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if arg == "--concurrent" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => concurrent_count = Some(n),
                _ => {
                    eprintln!("Error: concurrent count must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if arg == "-i" || arg == "--iterations" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => iterations = n,
                _ => {
                    eprintln!("Error: iterations must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Benchmark\n");
    
    // Show CPU info if requested or if running benchmarks
    if show_cpu_info || iterations > 1 || concurrent_count.is_some() {
        common::print_cpu_info();
    }
    
    if use_parsed_schema {
        println!("📦 Mode: ParsedSchema (parse once, reuse for all iterations)\n");
    }
    
    if let Some(count) = concurrent_count {
        println!("🔀 Concurrent evaluations: {} threads\n", count);
    } else if iterations > 1 {
        println!("🔄 Iterations per scenario: {}\n", iterations);
    }
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }

    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        println!("Running evaluation...\n");

        let (parse_time, eval_time, evaluated_schema, eval, iteration_times) = if use_parsed_schema {
            // ParsedSchema mode: parse once, reuse for all iterations/threads
            let start_time = Instant::now();
            
            let parsed_schema = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                    .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                Arc::new(ParsedSchema::parse(&schema_str)
                    .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
            };
            
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            // Concurrent mode with ParsedSchema
            if let Some(thread_count) = concurrent_count {
                use std::thread;
                
                let eval_start = Instant::now();
                let mut handles = vec![];
                
                for thread_id in 0..thread_count {
                    let parsed_clone = parsed_schema.clone();
                    let data_str_clone = data_str.clone();
                    let iter_count = iterations;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        for _ in 0..iter_count {
                            let iter_start = Instant::now();
                            let mut eval_instance = JSONEval::with_parsed_schema(
                                parsed_clone.clone(),
                                Some("{}"),
                                Some(&data_str_clone)
                            ).unwrap();
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None).unwrap();
                            last_schema = eval_instance.get_evaluated_schema(false);
                            thread_times.push(iter_start.elapsed());
                        }
                        
                        (thread_times, last_schema, thread_id)
                    });
                    handles.push(handle);
                }
                
                let mut all_iteration_times = Vec::new();
                let mut evaluated_schema = Value::Null;
                
                for handle in handles {
                    let (thread_times, thread_schema, thread_id) = handle.join().unwrap();
                    println!("  Thread {} completed {} iterations", thread_id, thread_times.len());
                    all_iteration_times.extend(thread_times);
                    evaluated_schema = thread_schema; // Use last thread's result
                }
                
                let eval_time = eval_start.elapsed();
                
                // Create a temp eval for metadata export
                let temp_eval = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                (parse_time, eval_time, evaluated_schema, temp_eval, all_iteration_times)
            } else {
                // Sequential iterations with ParsedSchema
                let eval_start = Instant::now();
                let mut evaluated_schema = Value::Null;
                let mut iteration_times = Vec::with_capacity(iterations);
                let mut eval_instance = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                for iter in 0..iterations {
                    let iter_start = Instant::now();
                    eval_instance.evaluate(&data_str, Some("{}"), None)
                        .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                    evaluated_schema = eval_instance.get_evaluated_schema(false);
                    iteration_times.push(iter_start.elapsed());
                    
                    if iterations > 1 && (iter + 1) % 10 == 0 {
                        print!(".");
                        if (iter + 1) % 50 == 0 {
                            println!(" {}/{}", iter + 1, iterations);
                        }
                    }
                }
                
                if iterations > 1 && iterations % 50 != 0 {
                    println!(" {}/{}", iterations, iterations);
                }
                
                let eval_time = eval_start.elapsed();
                (parse_time, eval_time, evaluated_schema, eval_instance, iteration_times)
            }
        } else {
            // Traditional mode: parse and create JSONEval each time
            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                JSONEval::new(&schema_str, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
            };
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            let eval_start = Instant::now();
            let mut evaluated_schema = Value::Null;
            let mut iteration_times = Vec::with_capacity(iterations);
            
            for iter in 0..iterations {
                let iter_start = Instant::now();
                eval.evaluate(&data_str, Some("{}"), None)
                    .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                evaluated_schema = eval.get_evaluated_schema(false);
                iteration_times.push(iter_start.elapsed());
                
                if iterations > 1 && (iter + 1) % 10 == 0 {
                    print!(".");
                    if (iter + 1) % 50 == 0 {
                        println!(" {}/{}", iter + 1, iterations);
                    }
                }
            }
            
            if iterations > 1 && iterations % 50 != 0 {
                println!(" {}/{}", iterations, iterations);
            }
            
            let eval_time = eval_start.elapsed();
            (parse_time, eval_time, evaluated_schema, eval, iteration_times)
        };
        
        // Calculate statistics
        let total_iterations = iteration_times.len();
        if total_iterations == 1 {
            println!("  Evaluation: {:?}", eval_time);
        } else {
            let avg_time = eval_time / total_iterations as u32;
            let min_time = iteration_times.iter().min().unwrap();
            let max_time = iteration_times.iter().max().unwrap();
            
            println!("  Total evaluation time: {:?}", eval_time);
            println!("  Total iterations: {}", total_iterations);
            println!("  Average per iteration: {:?}", avg_time);
            println!("  Min: {:?} | Max: {:?}", min_time, max_time);
            
            // Show cache statistics
            let cache_stats = eval.cache_stats();
            println!("  Cache: {} entries, {} hits, {} misses ({:.1}% hit rate)",
                cache_stats.entries,
                cache_stats.hits,
                cache_stats.misses,
                cache_stats.hit_rate * 100.0
            );
        }

        let total_time = parse_time + eval_time;
        println!("⏱️  Execution time: {:?}\n", total_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        // Track statistics
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary statistics
    if successful_scenarios > 0 {
        println!("\n{}", "=".repeat(50));
        println!("📊 Summary Statistics");
        println!("{}", "=".repeat(50));
        println!("Total scenarios run: {}", successful_scenarios);
        println!("Total parsing time: {:?}", total_parse_time);
        println!("Total evaluation time: {:?}", total_eval_time);
        println!("Total time: {:?}", total_parse_time + total_eval_time);
        
        if successful_scenarios > 1 {
            println!("\nAverage per scenario:");
            println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
            println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
        }
        
        if enable_comparison {
            println!("\nComparison failures: {}", comparison_failures);
        }
        
        println!("\n✅ All scenarios completed successfully!\n");
    }
}

pub fn clear_cache(&self)

Clear the cache manually

pub fn enable_cache(&mut self)

Enable caching

Examples found in repository

examples/cache_disable.rs (line 86)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

pub fn disable_cache(&mut self)

Disable caching

Examples found in repository

examples/cache_disable.rs (line 63)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

pub fn is_cache_enabled(&self) -> bool

Check if cache is enabled

Examples found in repository

examples/cache_disable.rs (line 45)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

pub fn cache_len(&self) -> usize

Get cache size

Examples found in repository

examples/cache_disable.rs (line 46)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

impl JSONEval

pub fn evaluate_dependents( &mut self, changed_paths: &[String], data: Option<&str>, context: Option<&str>, re_evaluate: bool, ) -> Result<Value, String>

Evaluate fields that depend on a changed path This processes all dependent fields transitively when a source field changes

impl JSONEval

pub fn evaluate( &mut self, data: &str, context: Option<&str>, paths: Option<&[String]>, ) -> Result<(), String>

Evaluate the schema with the given data and context.

Arguments

• data - The data to evaluate.
• context - The context to evaluate.

Returns

A Result indicating success or an error message.

Examples found in repository

examples/cache_demo.rs (line 74)

fn demo_local_cache() -> Result<(), Box<dyn std::error::Error>> {
    println!("📦 Example 1: Local Cache Instance");
    println!("Creating a dedicated cache for this application...\n");
    
    let cache = ParsedSchemaCache::new();
    
    // Simple schema
    let schema_json = r#"{
        "$params": {
            "rate": { "type": "number" }
        },
        "result": {
            "type": "number",
            "title": "Calculated Result",
            "$evaluation": {
                "logic": { "*": [{"var": "$rate"}, 100] }
            }
        }
    }"#;
    
    // Parse and cache with a custom key
    println!("📝 Parsing schema and caching with key 'calculation-v1'...");
    let parsed = ParsedSchema::parse(schema_json)?;
    cache.insert("calculation-v1".to_string(), Arc::new(parsed));
    
    println!("✅ Schema cached successfully");
    println!("   Cache size: {} entries", cache.len());
    println!("   Keys: {:?}\n", cache.keys());
    
    // Retrieve and use cached schema
    println!("🔍 Retrieving cached schema...");
    if let Some(cached_schema) = cache.get("calculation-v1") {
        println!("✅ Retrieved from cache");
        
        // Create JSONEval from cached ParsedSchema
        let mut eval = JSONEval::with_parsed_schema(cached_schema, Some(r#"{"rate": 1.5}"#), None)?;
        eval.evaluate("{}", None, None)?;
        
        let evaluated = eval.get_evaluated_schema(false);
        let result = evaluated.pointer("/result")
            .and_then(|v| v.as_f64())
            .unwrap_or(0.0);
        println!("   Evaluation result: {}\n", result);
    }
    
    // Check cache stats
    let stats = cache.stats();
    println!("📊 Cache Statistics: {}", stats);
    
    // Remove entry
    println!("\n🗑️  Removing 'calculation-v1' from cache...");
    cache.remove("calculation-v1");
    println!("   Cache size after removal: {}", cache.len());
    
    Ok(())
}

fn demo_global_cache() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌍 Example 2: Global Cache Instance");
    println!("Using the built-in PARSED_SCHEMA_CACHE...\n");
    
    let schema_json = r#"{
        "$params": {
            "x": { "type": "number" },
            "y": { "type": "number" }
        },
        "sum": {
            "type": "number",
            "$evaluation": { "+": [{"var": "$x"}, {"var": "$y"}] }
        }
    }"#;
    
    // Use global cache
    println!("📝 Caching schema globally with key 'math-operations'...");
    let parsed = ParsedSchema::parse(schema_json)?;
    PARSED_SCHEMA_CACHE.insert("math-operations".to_string(), Arc::new(parsed));
    
    println!("✅ Schema cached globally");
    println!("   Global cache size: {}\n", PARSED_SCHEMA_CACHE.len());
    
    // Access from anywhere in the application
    simulate_another_function()?;
    
    // Clean up
    println!("\n🧹 Clearing global cache...");
    PARSED_SCHEMA_CACHE.clear();
    println!("   Global cache size: {}", PARSED_SCHEMA_CACHE.len());
    
    Ok(())
}

fn simulate_another_function() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔄 In another function, accessing global cache...");
    
    if let Some(cached) = PARSED_SCHEMA_CACHE.get("math-operations") {
        println!("✅ Retrieved schema from global cache");
        
        let mut eval = JSONEval::with_parsed_schema(cached, Some(r#"{"x": 10, "y": 20}"#), None)?;
        eval.evaluate("{}", None, None)?;
        
        let evaluated = eval.get_evaluated_schema(false);
        let sum = evaluated.pointer("/sum")
            .and_then(|v| v.as_f64())
            .unwrap_or(0.0);
        println!("   Result: {}", sum);
    }
    
    Ok(())
}

fn demo_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ Example 3: Performance Comparison");
    println!("Comparing cached vs non-cached schema usage...\n");
    
    let schema_json = r#"{
        "$params": {
            "value": { "type": "number" }
        },
        "doubled": {
            "type": "number",
            "$evaluation": { "*": [{"var": "$value"}, 2] }
        },
        "tripled": {
            "type": "number",
            "$evaluation": { "*": [{"var": "$value"}, 3] }
        }
    }"#;
    
    let iterations = 100;
    
    // WITHOUT CACHE: Parse schema every time
    println!("🐌 Without cache (parse + evaluate each time):");
    let start = Instant::now();
    for i in 0..iterations {
        let context = format!(r#"{{"value": {}}}"#, i);
        let mut eval = JSONEval::new(schema_json, Some(&context), None)?;
        eval.evaluate("{}", None, None)?;
    }
    let without_cache = start.elapsed();
    println!("   Time: {:?}", without_cache);
    println!("   Avg per iteration: {:?}\n", without_cache / iterations);
    
    // WITH CACHE: Parse once, evaluate many times
    println!("🚀 With cache (parse once, reuse for all evaluations):");
    let cache = ParsedSchemaCache::new();
    
    // Parse once
    let parse_start = Instant::now();
    let parsed = ParsedSchema::parse(schema_json)?;
    cache.insert("perf-test".to_string(), Arc::new(parsed));
    let parse_time = parse_start.elapsed();
    
    // Evaluate many times
    let eval_start = Instant::now();
    for i in 0..iterations {
        if let Some(cached) = cache.get("perf-test") {
            let context = format!(r#"{{"value": {}}}"#, i);
            let mut eval = JSONEval::with_parsed_schema(cached.clone(), Some(&context), None)?;
            eval.evaluate("{}", None, None)?;
        }
    }
    let eval_time = eval_start.elapsed();
    let with_cache = parse_time + eval_time;
    
    println!("   Parse time: {:?}", parse_time);
    println!("   Eval time: {:?}", eval_time);
    println!("   Total time: {:?}", with_cache);
    println!("   Avg per iteration: {:?}\n", eval_time / iterations);
    
    let speedup = without_cache.as_secs_f64() / with_cache.as_secs_f64();
    println!("📈 Speedup: {:.2}x faster", speedup);
    
    Ok(())
}

examples/cache_disable.rs (line 48)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

examples/spaj_toggle.rs (line 49)

fn main() {
    println!("\n🚀 JSON Evaluation - SPAJ Toggle Example\n");

    let schema_path = Path::new("samples/spaj.json");
    let schema_str = fs::read_to_string(schema_path).expect("Failed to read schema");

    // Initial data with minimal context required
    let context_str = json!({
        "agentProfile": { "sob": "AG" } 
    }).to_string();

    let initial_data = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": false
            }
        }
    }).to_string();

    // Initialize logic
    let mut eval = JSONEval::new(&schema_str, Some(&context_str), Some(&initial_data))
        .expect("Failed to create JSONEval");

    // Helper to check visibility
    let check_visibility = |eval: &mut JSONEval, expected_hidden: bool, step: &str| {
        let result = eval.get_evaluated_schema(true);
        let hidden = result.pointer("/illustration/properties/basicinformation/properties/print_poladdress/condition/hidden")
            .and_then(|v| v.as_bool());
        
        match hidden {
            Some(val) => {
                if val == expected_hidden {
                    println!("✅ {}: Hidden = {} (Expected: {})", step, val, expected_hidden);
                } else {
                    println!("❌ {}: Hidden = {} (Expected: {})", step, val, expected_hidden);
                }
            },
            None => println!("❌ {}: 'hidden' property not found", step),
        }
    };

    // Step 1: Initial state (false)
    println!("Step 1: Initial State (print_polflag: false)");
    eval.evaluate(&initial_data, Some(&context_str), None).expect("Evaluation failed");
    check_visibility(&mut eval, true, "Initial check");

    // Step 2: Toggle to true
    println!("\nStep 2: Toggle True (print_polflag: true)");
    let data_true = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": true
            }
        }
    }).to_string();
    eval.evaluate(&data_true, Some(&context_str), None).expect("Evaluation failed");
    check_visibility(&mut eval, false, "Toggle ON check");

    // Step 3: Toggle back to false
    println!("\nStep 3: Toggle False (print_polflag: false)");
    let data_false = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": false
            }
        }
    }).to_string();
    eval.evaluate(&data_false, Some(&context_str), None).expect("Evaluation failed");
    
    let hidden_path = "#/illustration/properties/basicinformation/properties/print_poladdress/condition/hidden";
    if let Some(deps) = eval.dependencies.get(hidden_path) {
        println!("Debug: Dependencies for hidden: {:?}", deps);
    } else {
        println!("Debug: No dependencies found for hidden path");
    }

    // Debug: Print current flag value
    if let Some(val) = eval.get_evaluated_schema(true).pointer("/illustration/properties/basicinformation/properties/print_polflag/value") {
         println!("Debug: print_polflag value is: {}", val);
    }

    check_visibility(&mut eval, true, "Toggle OFF check");
}

examples/basic_msgpack.rs (line 138)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic_msgpack");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (MessagePack Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter to only MessagePack scenarios
    scenarios.retain(|s| s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No MessagePack scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No MessagePack scenarios discovered in `{}`. Add files like `name.bform` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} MessagePack scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} (MessagePack)", scenario.schema_path.display());
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (new_from_msgpack)
        let parse_start = Instant::now();
        
        let schema_msgpack = fs::read(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
        
        let mut eval = JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (msgpack): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/basic.rs (line 139)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (JSON Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter out MessagePack scenarios - only use JSON
    scenarios.retain(|s| !s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (JSONEval::new)
        let parse_start = Instant::now();
        
        let schema_str = fs::read_to_string(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (new): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let schema_value = eval.get_schema_value();
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));
        let value_path = samples_dir.join(format!("{}-schema-value.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        fs::write(&value_path, common::pretty_json(&schema_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", value_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}\n", value_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/basic_parsed.rs (line 149)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic_parsed");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (ParsedSchema)\n");
    println!("📦 Using Arc<ParsedSchema> for efficient caching\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema once
        let parse_start = Instant::now();
        let parsed_schema = if scenario.is_msgpack {
            let schema_msgpack = fs::read(&scenario.schema_path)
                .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
            println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
            Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
        } else {
            let schema_str = fs::read_to_string(&scenario.schema_path)
                .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
            Arc::new(ParsedSchema::parse(&schema_str)
                .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
        };
        let parse_time = parse_start.elapsed();
        println!("  📝 Schema parsing: {:?}", parse_time);
        
        // Step 2: Create JSONEval from ParsedSchema (reuses compiled logic)
        let eval_start = Instant::now();
        let mut eval = JSONEval::with_parsed_schema(
            parsed_schema.clone(),  // Arc::clone is cheap!
            Some("{}"),
            Some(&data_str)
        ).unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));

        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parsing time: {:?}", total_parse_time);
    println!("Total evaluation time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("\nComparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

Additional examples can be found in:

• examples/benchmark.rs

impl JSONEval

pub fn get_evaluated_schema(&self, include_hidden: bool) -> Value

Get the fully evaluated schema

Arguments

• include_hidden - If true, hidden fields are included (but marked). If false, hidden fields are removed from the output.

Examples found in repository

examples/cache_demo.rs (line 76)

fn demo_local_cache() -> Result<(), Box<dyn std::error::Error>> {
    println!("📦 Example 1: Local Cache Instance");
    println!("Creating a dedicated cache for this application...\n");
    
    let cache = ParsedSchemaCache::new();
    
    // Simple schema
    let schema_json = r#"{
        "$params": {
            "rate": { "type": "number" }
        },
        "result": {
            "type": "number",
            "title": "Calculated Result",
            "$evaluation": {
                "logic": { "*": [{"var": "$rate"}, 100] }
            }
        }
    }"#;
    
    // Parse and cache with a custom key
    println!("📝 Parsing schema and caching with key 'calculation-v1'...");
    let parsed = ParsedSchema::parse(schema_json)?;
    cache.insert("calculation-v1".to_string(), Arc::new(parsed));
    
    println!("✅ Schema cached successfully");
    println!("   Cache size: {} entries", cache.len());
    println!("   Keys: {:?}\n", cache.keys());
    
    // Retrieve and use cached schema
    println!("🔍 Retrieving cached schema...");
    if let Some(cached_schema) = cache.get("calculation-v1") {
        println!("✅ Retrieved from cache");
        
        // Create JSONEval from cached ParsedSchema
        let mut eval = JSONEval::with_parsed_schema(cached_schema, Some(r#"{"rate": 1.5}"#), None)?;
        eval.evaluate("{}", None, None)?;
        
        let evaluated = eval.get_evaluated_schema(false);
        let result = evaluated.pointer("/result")
            .and_then(|v| v.as_f64())
            .unwrap_or(0.0);
        println!("   Evaluation result: {}\n", result);
    }
    
    // Check cache stats
    let stats = cache.stats();
    println!("📊 Cache Statistics: {}", stats);
    
    // Remove entry
    println!("\n🗑️  Removing 'calculation-v1' from cache...");
    cache.remove("calculation-v1");
    println!("   Cache size after removal: {}", cache.len());
    
    Ok(())
}

fn demo_global_cache() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌍 Example 2: Global Cache Instance");
    println!("Using the built-in PARSED_SCHEMA_CACHE...\n");
    
    let schema_json = r#"{
        "$params": {
            "x": { "type": "number" },
            "y": { "type": "number" }
        },
        "sum": {
            "type": "number",
            "$evaluation": { "+": [{"var": "$x"}, {"var": "$y"}] }
        }
    }"#;
    
    // Use global cache
    println!("📝 Caching schema globally with key 'math-operations'...");
    let parsed = ParsedSchema::parse(schema_json)?;
    PARSED_SCHEMA_CACHE.insert("math-operations".to_string(), Arc::new(parsed));
    
    println!("✅ Schema cached globally");
    println!("   Global cache size: {}\n", PARSED_SCHEMA_CACHE.len());
    
    // Access from anywhere in the application
    simulate_another_function()?;
    
    // Clean up
    println!("\n🧹 Clearing global cache...");
    PARSED_SCHEMA_CACHE.clear();
    println!("   Global cache size: {}", PARSED_SCHEMA_CACHE.len());
    
    Ok(())
}

fn simulate_another_function() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔄 In another function, accessing global cache...");
    
    if let Some(cached) = PARSED_SCHEMA_CACHE.get("math-operations") {
        println!("✅ Retrieved schema from global cache");
        
        let mut eval = JSONEval::with_parsed_schema(cached, Some(r#"{"x": 10, "y": 20}"#), None)?;
        eval.evaluate("{}", None, None)?;
        
        let evaluated = eval.get_evaluated_schema(false);
        let sum = evaluated.pointer("/sum")
            .and_then(|v| v.as_f64())
            .unwrap_or(0.0);
        println!("   Result: {}", sum);
    }
    
    Ok(())
}

examples/spaj_toggle.rs (line 31)

fn main() {
    println!("\n🚀 JSON Evaluation - SPAJ Toggle Example\n");

    let schema_path = Path::new("samples/spaj.json");
    let schema_str = fs::read_to_string(schema_path).expect("Failed to read schema");

    // Initial data with minimal context required
    let context_str = json!({
        "agentProfile": { "sob": "AG" } 
    }).to_string();

    let initial_data = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": false
            }
        }
    }).to_string();

    // Initialize logic
    let mut eval = JSONEval::new(&schema_str, Some(&context_str), Some(&initial_data))
        .expect("Failed to create JSONEval");

    // Helper to check visibility
    let check_visibility = |eval: &mut JSONEval, expected_hidden: bool, step: &str| {
        let result = eval.get_evaluated_schema(true);
        let hidden = result.pointer("/illustration/properties/basicinformation/properties/print_poladdress/condition/hidden")
            .and_then(|v| v.as_bool());
        
        match hidden {
            Some(val) => {
                if val == expected_hidden {
                    println!("✅ {}: Hidden = {} (Expected: {})", step, val, expected_hidden);
                } else {
                    println!("❌ {}: Hidden = {} (Expected: {})", step, val, expected_hidden);
                }
            },
            None => println!("❌ {}: 'hidden' property not found", step),
        }
    };

    // Step 1: Initial state (false)
    println!("Step 1: Initial State (print_polflag: false)");
    eval.evaluate(&initial_data, Some(&context_str), None).expect("Evaluation failed");
    check_visibility(&mut eval, true, "Initial check");

    // Step 2: Toggle to true
    println!("\nStep 2: Toggle True (print_polflag: true)");
    let data_true = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": true
            }
        }
    }).to_string();
    eval.evaluate(&data_true, Some(&context_str), None).expect("Evaluation failed");
    check_visibility(&mut eval, false, "Toggle ON check");

    // Step 3: Toggle back to false
    println!("\nStep 3: Toggle False (print_polflag: false)");
    let data_false = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": false
            }
        }
    }).to_string();
    eval.evaluate(&data_false, Some(&context_str), None).expect("Evaluation failed");
    
    let hidden_path = "#/illustration/properties/basicinformation/properties/print_poladdress/condition/hidden";
    if let Some(deps) = eval.dependencies.get(hidden_path) {
        println!("Debug: Dependencies for hidden: {:?}", deps);
    } else {
        println!("Debug: No dependencies found for hidden path");
    }

    // Debug: Print current flag value
    if let Some(val) = eval.get_evaluated_schema(true).pointer("/illustration/properties/basicinformation/properties/print_polflag/value") {
         println!("Debug: print_polflag value is: {}", val);
    }

    check_visibility(&mut eval, true, "Toggle OFF check");
}

examples/basic_msgpack.rs (line 141)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic_msgpack");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (MessagePack Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter to only MessagePack scenarios
    scenarios.retain(|s| s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No MessagePack scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No MessagePack scenarios discovered in `{}`. Add files like `name.bform` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} MessagePack scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} (MessagePack)", scenario.schema_path.display());
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (new_from_msgpack)
        let parse_start = Instant::now();
        
        let schema_msgpack = fs::read(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
        
        let mut eval = JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (msgpack): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/basic.rs (line 142)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (JSON Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter out MessagePack scenarios - only use JSON
    scenarios.retain(|s| !s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (JSONEval::new)
        let parse_start = Instant::now();
        
        let schema_str = fs::read_to_string(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (new): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let schema_value = eval.get_schema_value();
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));
        let value_path = samples_dir.join(format!("{}-schema-value.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        fs::write(&value_path, common::pretty_json(&schema_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", value_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}\n", value_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/basic_parsed.rs (line 152)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic_parsed");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (ParsedSchema)\n");
    println!("📦 Using Arc<ParsedSchema> for efficient caching\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema once
        let parse_start = Instant::now();
        let parsed_schema = if scenario.is_msgpack {
            let schema_msgpack = fs::read(&scenario.schema_path)
                .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
            println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
            Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
        } else {
            let schema_str = fs::read_to_string(&scenario.schema_path)
                .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
            Arc::new(ParsedSchema::parse(&schema_str)
                .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
        };
        let parse_time = parse_start.elapsed();
        println!("  📝 Schema parsing: {:?}", parse_time);
        
        // Step 2: Create JSONEval from ParsedSchema (reuses compiled logic)
        let eval_start = Instant::now();
        let mut eval = JSONEval::with_parsed_schema(
            parsed_schema.clone(),  // Arc::clone is cheap!
            Some("{}"),
            Some(&data_str)
        ).unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));

        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parsing time: {:?}", total_parse_time);
    println!("Total evaluation time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("\nComparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/benchmark.rs (line 222)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("benchmark");
    
    let mut iterations = 1usize;
    let mut scenario_filter: Option<String> = None;
    let mut show_cpu_info = false;
    let mut use_parsed_schema = false;
    let mut concurrent_count: Option<usize> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--cpu-info" {
            show_cpu_info = true;
        } else if arg == "--parsed" {
            use_parsed_schema = true;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if arg == "--concurrent" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => concurrent_count = Some(n),
                _ => {
                    eprintln!("Error: concurrent count must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if arg == "-i" || arg == "--iterations" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => iterations = n,
                _ => {
                    eprintln!("Error: iterations must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Benchmark\n");
    
    // Show CPU info if requested or if running benchmarks
    if show_cpu_info || iterations > 1 || concurrent_count.is_some() {
        common::print_cpu_info();
    }
    
    if use_parsed_schema {
        println!("📦 Mode: ParsedSchema (parse once, reuse for all iterations)\n");
    }
    
    if let Some(count) = concurrent_count {
        println!("🔀 Concurrent evaluations: {} threads\n", count);
    } else if iterations > 1 {
        println!("🔄 Iterations per scenario: {}\n", iterations);
    }
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }

    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        println!("Running evaluation...\n");

        let (parse_time, eval_time, evaluated_schema, eval, iteration_times) = if use_parsed_schema {
            // ParsedSchema mode: parse once, reuse for all iterations/threads
            let start_time = Instant::now();
            
            let parsed_schema = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                    .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                Arc::new(ParsedSchema::parse(&schema_str)
                    .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
            };
            
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            // Concurrent mode with ParsedSchema
            if let Some(thread_count) = concurrent_count {
                use std::thread;
                
                let eval_start = Instant::now();
                let mut handles = vec![];
                
                for thread_id in 0..thread_count {
                    let parsed_clone = parsed_schema.clone();
                    let data_str_clone = data_str.clone();
                    let iter_count = iterations;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        for _ in 0..iter_count {
                            let iter_start = Instant::now();
                            let mut eval_instance = JSONEval::with_parsed_schema(
                                parsed_clone.clone(),
                                Some("{}"),
                                Some(&data_str_clone)
                            ).unwrap();
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None).unwrap();
                            last_schema = eval_instance.get_evaluated_schema(false);
                            thread_times.push(iter_start.elapsed());
                        }
                        
                        (thread_times, last_schema, thread_id)
                    });
                    handles.push(handle);
                }
                
                let mut all_iteration_times = Vec::new();
                let mut evaluated_schema = Value::Null;
                
                for handle in handles {
                    let (thread_times, thread_schema, thread_id) = handle.join().unwrap();
                    println!("  Thread {} completed {} iterations", thread_id, thread_times.len());
                    all_iteration_times.extend(thread_times);
                    evaluated_schema = thread_schema; // Use last thread's result
                }
                
                let eval_time = eval_start.elapsed();
                
                // Create a temp eval for metadata export
                let temp_eval = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                (parse_time, eval_time, evaluated_schema, temp_eval, all_iteration_times)
            } else {
                // Sequential iterations with ParsedSchema
                let eval_start = Instant::now();
                let mut evaluated_schema = Value::Null;
                let mut iteration_times = Vec::with_capacity(iterations);
                let mut eval_instance = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                for iter in 0..iterations {
                    let iter_start = Instant::now();
                    eval_instance.evaluate(&data_str, Some("{}"), None)
                        .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                    evaluated_schema = eval_instance.get_evaluated_schema(false);
                    iteration_times.push(iter_start.elapsed());
                    
                    if iterations > 1 && (iter + 1) % 10 == 0 {
                        print!(".");
                        if (iter + 1) % 50 == 0 {
                            println!(" {}/{}", iter + 1, iterations);
                        }
                    }
                }
                
                if iterations > 1 && iterations % 50 != 0 {
                    println!(" {}/{}", iterations, iterations);
                }
                
                let eval_time = eval_start.elapsed();
                (parse_time, eval_time, evaluated_schema, eval_instance, iteration_times)
            }
        } else {
            // Traditional mode: parse and create JSONEval each time
            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                JSONEval::new(&schema_str, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
            };
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            let eval_start = Instant::now();
            let mut evaluated_schema = Value::Null;
            let mut iteration_times = Vec::with_capacity(iterations);
            
            for iter in 0..iterations {
                let iter_start = Instant::now();
                eval.evaluate(&data_str, Some("{}"), None)
                    .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                evaluated_schema = eval.get_evaluated_schema(false);
                iteration_times.push(iter_start.elapsed());
                
                if iterations > 1 && (iter + 1) % 10 == 0 {
                    print!(".");
                    if (iter + 1) % 50 == 0 {
                        println!(" {}/{}", iter + 1, iterations);
                    }
                }
            }
            
            if iterations > 1 && iterations % 50 != 0 {
                println!(" {}/{}", iterations, iterations);
            }
            
            let eval_time = eval_start.elapsed();
            (parse_time, eval_time, evaluated_schema, eval, iteration_times)
        };
        
        // Calculate statistics
        let total_iterations = iteration_times.len();
        if total_iterations == 1 {
            println!("  Evaluation: {:?}", eval_time);
        } else {
            let avg_time = eval_time / total_iterations as u32;
            let min_time = iteration_times.iter().min().unwrap();
            let max_time = iteration_times.iter().max().unwrap();
            
            println!("  Total evaluation time: {:?}", eval_time);
            println!("  Total iterations: {}", total_iterations);
            println!("  Average per iteration: {:?}", avg_time);
            println!("  Min: {:?} | Max: {:?}", min_time, max_time);
            
            // Show cache statistics
            let cache_stats = eval.cache_stats();
            println!("  Cache: {} entries, {} hits, {} misses ({:.1}% hit rate)",
                cache_stats.entries,
                cache_stats.hits,
                cache_stats.misses,
                cache_stats.hit_rate * 100.0
            );
        }

        let total_time = parse_time + eval_time;
        println!("⏱️  Execution time: {:?}\n", total_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        // Track statistics
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary statistics
    if successful_scenarios > 0 {
        println!("\n{}", "=".repeat(50));
        println!("📊 Summary Statistics");
        println!("{}", "=".repeat(50));
        println!("Total scenarios run: {}", successful_scenarios);
        println!("Total parsing time: {:?}", total_parse_time);
        println!("Total evaluation time: {:?}", total_eval_time);
        println!("Total time: {:?}", total_parse_time + total_eval_time);
        
        if successful_scenarios > 1 {
            println!("\nAverage per scenario:");
            println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
            println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
        }
        
        if enable_comparison {
            println!("\nComparison failures: {}", comparison_failures);
        }
        
        println!("\n✅ All scenarios completed successfully!\n");
    }
}

pub fn get_evaluated_schema_with_layout(&self, include_hidden: bool) -> Value

Get evaluated schema with layout resolution

pub fn get_schema_value_by_path(&self, path: &str) -> Option<Value>

Get specific schema value by path

pub fn get_schema_value(&self) -> Value

Get all schema values (data view) This corresponds to subform.get_schema_value() usage

Examples found in repository

examples/basic.rs (line 143)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (JSON Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter out MessagePack scenarios - only use JSON
    scenarios.retain(|s| !s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (JSONEval::new)
        let parse_start = Instant::now();
        
        let schema_str = fs::read_to_string(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (new): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let schema_value = eval.get_schema_value();
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));
        let value_path = samples_dir.join(format!("{}-schema-value.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        fs::write(&value_path, common::pretty_json(&schema_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", value_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}\n", value_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

pub fn get_evaluated_schema_without_params(&self, include_hidden: bool) -> Value

Get evaluated schema without $params

pub fn get_evaluated_schema_msgpack( &self, include_hidden: bool, ) -> Result<Vec<u8>, String>

Get evaluated schema as MessagePack bytes

pub fn get_evaluated_schema_by_path( &self, path: &str, _skip_layout: bool, ) -> Option<Value>

Get value from evaluated schema by path

pub fn get_evaluated_schema_by_paths( &self, paths: &[String], _skip_layout: bool, format: ReturnFormat, ) -> Value

Get evaluated schema parts by multiple paths

pub fn get_schema_by_path(&self, path: &str) -> Option<Value>

Get original (unevaluated) schema by path

pub fn get_schema_by_paths( &self, paths: &[String], format: ReturnFormat, ) -> Value

Get original schema by multiple paths

pub fn flatten_object( prefix: &str, value: &Value, result: &mut Map<String, Value>, )

Flatten a nested object key-value pair to dotted keys

pub fn convert_to_format(value: Value, format: ReturnFormat) -> Value

impl JSONEval

pub fn new( schema: &str, context: Option<&str>, data: Option<&str>, ) -> Result<Self, Error>

Examples found in repository

examples/cache_demo.rs (line 173)

fn demo_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ Example 3: Performance Comparison");
    println!("Comparing cached vs non-cached schema usage...\n");
    
    let schema_json = r#"{
        "$params": {
            "value": { "type": "number" }
        },
        "doubled": {
            "type": "number",
            "$evaluation": { "*": [{"var": "$value"}, 2] }
        },
        "tripled": {
            "type": "number",
            "$evaluation": { "*": [{"var": "$value"}, 3] }
        }
    }"#;
    
    let iterations = 100;
    
    // WITHOUT CACHE: Parse schema every time
    println!("🐌 Without cache (parse + evaluate each time):");
    let start = Instant::now();
    for i in 0..iterations {
        let context = format!(r#"{{"value": {}}}"#, i);
        let mut eval = JSONEval::new(schema_json, Some(&context), None)?;
        eval.evaluate("{}", None, None)?;
    }
    let without_cache = start.elapsed();
    println!("   Time: {:?}", without_cache);
    println!("   Avg per iteration: {:?}\n", without_cache / iterations);
    
    // WITH CACHE: Parse once, evaluate many times
    println!("🚀 With cache (parse once, reuse for all evaluations):");
    let cache = ParsedSchemaCache::new();
    
    // Parse once
    let parse_start = Instant::now();
    let parsed = ParsedSchema::parse(schema_json)?;
    cache.insert("perf-test".to_string(), Arc::new(parsed));
    let parse_time = parse_start.elapsed();
    
    // Evaluate many times
    let eval_start = Instant::now();
    for i in 0..iterations {
        if let Some(cached) = cache.get("perf-test") {
            let context = format!(r#"{{"value": {}}}"#, i);
            let mut eval = JSONEval::with_parsed_schema(cached.clone(), Some(&context), None)?;
            eval.evaluate("{}", None, None)?;
        }
    }
    let eval_time = eval_start.elapsed();
    let with_cache = parse_time + eval_time;
    
    println!("   Parse time: {:?}", parse_time);
    println!("   Eval time: {:?}", eval_time);
    println!("   Total time: {:?}", with_cache);
    println!("   Avg per iteration: {:?}\n", eval_time / iterations);
    
    let speedup = without_cache.as_secs_f64() / with_cache.as_secs_f64();
    println!("📈 Speedup: {:.2}x faster", speedup);
    
    Ok(())
}

examples/cache_disable.rs (line 43)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "price": {
                "type": "number"
            },
            "tax": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "*": [
                            { "$ref": "#/properties/price" },
                            0.1
                        ]
                    }
                }
            },
            "total": {
                "type": "number",
                "value": {
                    "$evaluation": {
                        "+": [
                            { "$ref": "#/properties/price" },
                            { "$ref": "#/properties/tax" }
                        ]
                    }
                }
            }
        }
    });

    let schema_str = serde_json::to_string(&schema).unwrap();
    
    println!("=== Example 1: With Caching (Default) ===");
    {
        let data = json!({ "price": 100 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
    }
    
    println!("\n=== Example 2: Without Caching (Web API Mode) ===");
    {
        let data = json!({ "price": 200 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable caching for single-use web API scenario
        eval.disable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        println!("Initial cache size: {}", eval.cache_len());
        
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("After evaluation cache size: {}", eval.cache_len());
        let stats = eval.cache_stats();
        println!("Cache stats: {}", stats);
        
        println!("\n✅ No cache overhead - perfect for web APIs!");
    }
    
    println!("\n=== Example 3: Re-enabling Cache ===");
    {
        let data = json!({ "price": 300 });
        let data_str = serde_json::to_string(&data).unwrap();
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str)).unwrap();
        
        // Disable then re-enable
        eval.disable_cache();
        eval.enable_cache();
        
        println!("Cache enabled: {}", eval.is_cache_enabled());
        eval.evaluate(&data_str, None, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

examples/spaj_toggle.rs (line 26)

fn main() {
    println!("\n🚀 JSON Evaluation - SPAJ Toggle Example\n");

    let schema_path = Path::new("samples/spaj.json");
    let schema_str = fs::read_to_string(schema_path).expect("Failed to read schema");

    // Initial data with minimal context required
    let context_str = json!({
        "agentProfile": { "sob": "AG" } 
    }).to_string();

    let initial_data = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": false
            }
        }
    }).to_string();

    // Initialize logic
    let mut eval = JSONEval::new(&schema_str, Some(&context_str), Some(&initial_data))
        .expect("Failed to create JSONEval");

    // Helper to check visibility
    let check_visibility = |eval: &mut JSONEval, expected_hidden: bool, step: &str| {
        let result = eval.get_evaluated_schema(true);
        let hidden = result.pointer("/illustration/properties/basicinformation/properties/print_poladdress/condition/hidden")
            .and_then(|v| v.as_bool());
        
        match hidden {
            Some(val) => {
                if val == expected_hidden {
                    println!("✅ {}: Hidden = {} (Expected: {})", step, val, expected_hidden);
                } else {
                    println!("❌ {}: Hidden = {} (Expected: {})", step, val, expected_hidden);
                }
            },
            None => println!("❌ {}: 'hidden' property not found", step),
        }
    };

    // Step 1: Initial state (false)
    println!("Step 1: Initial State (print_polflag: false)");
    eval.evaluate(&initial_data, Some(&context_str), None).expect("Evaluation failed");
    check_visibility(&mut eval, true, "Initial check");

    // Step 2: Toggle to true
    println!("\nStep 2: Toggle True (print_polflag: true)");
    let data_true = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": true
            }
        }
    }).to_string();
    eval.evaluate(&data_true, Some(&context_str), None).expect("Evaluation failed");
    check_visibility(&mut eval, false, "Toggle ON check");

    // Step 3: Toggle back to false
    println!("\nStep 3: Toggle False (print_polflag: false)");
    let data_false = json!({
        "illustration": {
            "basicinformation": {
                "print_polflag": false
            }
        }
    }).to_string();
    eval.evaluate(&data_false, Some(&context_str), None).expect("Evaluation failed");
    
    let hidden_path = "#/illustration/properties/basicinformation/properties/print_poladdress/condition/hidden";
    if let Some(deps) = eval.dependencies.get(hidden_path) {
        println!("Debug: Dependencies for hidden: {:?}", deps);
    } else {
        println!("Debug: No dependencies found for hidden path");
    }

    // Debug: Print current flag value
    if let Some(val) = eval.get_evaluated_schema(true).pointer("/illustration/properties/basicinformation/properties/print_polflag/value") {
         println!("Debug: print_polflag value is: {}", val);
    }

    check_visibility(&mut eval, true, "Toggle OFF check");
}

examples/basic.rs (line 130)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (JSON Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter out MessagePack scenarios - only use JSON
    scenarios.retain(|s| !s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (JSONEval::new)
        let parse_start = Instant::now();
        
        let schema_str = fs::read_to_string(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        let mut eval = JSONEval::new(&schema_str, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (new): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let schema_value = eval.get_schema_value();
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));
        let value_path = samples_dir.join(format!("{}-schema-value.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        fs::write(&value_path, common::pretty_json(&schema_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", value_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}\n", value_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/benchmark.rs (line 296)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("benchmark");
    
    let mut iterations = 1usize;
    let mut scenario_filter: Option<String> = None;
    let mut show_cpu_info = false;
    let mut use_parsed_schema = false;
    let mut concurrent_count: Option<usize> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--cpu-info" {
            show_cpu_info = true;
        } else if arg == "--parsed" {
            use_parsed_schema = true;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if arg == "--concurrent" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => concurrent_count = Some(n),
                _ => {
                    eprintln!("Error: concurrent count must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if arg == "-i" || arg == "--iterations" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => iterations = n,
                _ => {
                    eprintln!("Error: iterations must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Benchmark\n");
    
    // Show CPU info if requested or if running benchmarks
    if show_cpu_info || iterations > 1 || concurrent_count.is_some() {
        common::print_cpu_info();
    }
    
    if use_parsed_schema {
        println!("📦 Mode: ParsedSchema (parse once, reuse for all iterations)\n");
    }
    
    if let Some(count) = concurrent_count {
        println!("🔀 Concurrent evaluations: {} threads\n", count);
    } else if iterations > 1 {
        println!("🔄 Iterations per scenario: {}\n", iterations);
    }
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }

    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        println!("Running evaluation...\n");

        let (parse_time, eval_time, evaluated_schema, eval, iteration_times) = if use_parsed_schema {
            // ParsedSchema mode: parse once, reuse for all iterations/threads
            let start_time = Instant::now();
            
            let parsed_schema = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                    .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                Arc::new(ParsedSchema::parse(&schema_str)
                    .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
            };
            
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            // Concurrent mode with ParsedSchema
            if let Some(thread_count) = concurrent_count {
                use std::thread;
                
                let eval_start = Instant::now();
                let mut handles = vec![];
                
                for thread_id in 0..thread_count {
                    let parsed_clone = parsed_schema.clone();
                    let data_str_clone = data_str.clone();
                    let iter_count = iterations;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        for _ in 0..iter_count {
                            let iter_start = Instant::now();
                            let mut eval_instance = JSONEval::with_parsed_schema(
                                parsed_clone.clone(),
                                Some("{}"),
                                Some(&data_str_clone)
                            ).unwrap();
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None).unwrap();
                            last_schema = eval_instance.get_evaluated_schema(false);
                            thread_times.push(iter_start.elapsed());
                        }
                        
                        (thread_times, last_schema, thread_id)
                    });
                    handles.push(handle);
                }
                
                let mut all_iteration_times = Vec::new();
                let mut evaluated_schema = Value::Null;
                
                for handle in handles {
                    let (thread_times, thread_schema, thread_id) = handle.join().unwrap();
                    println!("  Thread {} completed {} iterations", thread_id, thread_times.len());
                    all_iteration_times.extend(thread_times);
                    evaluated_schema = thread_schema; // Use last thread's result
                }
                
                let eval_time = eval_start.elapsed();
                
                // Create a temp eval for metadata export
                let temp_eval = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                (parse_time, eval_time, evaluated_schema, temp_eval, all_iteration_times)
            } else {
                // Sequential iterations with ParsedSchema
                let eval_start = Instant::now();
                let mut evaluated_schema = Value::Null;
                let mut iteration_times = Vec::with_capacity(iterations);
                let mut eval_instance = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                for iter in 0..iterations {
                    let iter_start = Instant::now();
                    eval_instance.evaluate(&data_str, Some("{}"), None)
                        .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                    evaluated_schema = eval_instance.get_evaluated_schema(false);
                    iteration_times.push(iter_start.elapsed());
                    
                    if iterations > 1 && (iter + 1) % 10 == 0 {
                        print!(".");
                        if (iter + 1) % 50 == 0 {
                            println!(" {}/{}", iter + 1, iterations);
                        }
                    }
                }
                
                if iterations > 1 && iterations % 50 != 0 {
                    println!(" {}/{}", iterations, iterations);
                }
                
                let eval_time = eval_start.elapsed();
                (parse_time, eval_time, evaluated_schema, eval_instance, iteration_times)
            }
        } else {
            // Traditional mode: parse and create JSONEval each time
            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                JSONEval::new(&schema_str, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
            };
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            let eval_start = Instant::now();
            let mut evaluated_schema = Value::Null;
            let mut iteration_times = Vec::with_capacity(iterations);
            
            for iter in 0..iterations {
                let iter_start = Instant::now();
                eval.evaluate(&data_str, Some("{}"), None)
                    .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                evaluated_schema = eval.get_evaluated_schema(false);
                iteration_times.push(iter_start.elapsed());
                
                if iterations > 1 && (iter + 1) % 10 == 0 {
                    print!(".");
                    if (iter + 1) % 50 == 0 {
                        println!(" {}/{}", iter + 1, iterations);
                    }
                }
            }
            
            if iterations > 1 && iterations % 50 != 0 {
                println!(" {}/{}", iterations, iterations);
            }
            
            let eval_time = eval_start.elapsed();
            (parse_time, eval_time, evaluated_schema, eval, iteration_times)
        };
        
        // Calculate statistics
        let total_iterations = iteration_times.len();
        if total_iterations == 1 {
            println!("  Evaluation: {:?}", eval_time);
        } else {
            let avg_time = eval_time / total_iterations as u32;
            let min_time = iteration_times.iter().min().unwrap();
            let max_time = iteration_times.iter().max().unwrap();
            
            println!("  Total evaluation time: {:?}", eval_time);
            println!("  Total iterations: {}", total_iterations);
            println!("  Average per iteration: {:?}", avg_time);
            println!("  Min: {:?} | Max: {:?}", min_time, max_time);
            
            // Show cache statistics
            let cache_stats = eval.cache_stats();
            println!("  Cache: {} entries, {} hits, {} misses ({:.1}% hit rate)",
                cache_stats.entries,
                cache_stats.hits,
                cache_stats.misses,
                cache_stats.hit_rate * 100.0
            );
        }

        let total_time = parse_time + eval_time;
        println!("⏱️  Execution time: {:?}\n", total_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        // Track statistics
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary statistics
    if successful_scenarios > 0 {
        println!("\n{}", "=".repeat(50));
        println!("📊 Summary Statistics");
        println!("{}", "=".repeat(50));
        println!("Total scenarios run: {}", successful_scenarios);
        println!("Total parsing time: {:?}", total_parse_time);
        println!("Total evaluation time: {:?}", total_eval_time);
        println!("Total time: {:?}", total_parse_time + total_eval_time);
        
        if successful_scenarios > 1 {
            println!("\nAverage per scenario:");
            println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
            println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
        }
        
        if enable_comparison {
            println!("\nComparison failures: {}", comparison_failures);
        }
        
        println!("\n✅ All scenarios completed successfully!\n");
    }
}

pub fn new_from_msgpack( schema_msgpack: &[u8], context: Option<&str>, data: Option<&str>, ) -> Result<Self, String>

Create a new JSONEval instance from MessagePack-encoded schema

Arguments

• schema_msgpack - MessagePack-encoded schema bytes
• context - Optional JSON context string
• data - Optional JSON data string

Returns

A Result containing the JSONEval instance or an error

Examples found in repository

examples/basic_msgpack.rs (line 129)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic_msgpack");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (MessagePack Schema)\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter to only MessagePack scenarios
    scenarios.retain(|s| s.is_msgpack);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No MessagePack scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No MessagePack scenarios discovered in `{}`. Add files like `name.bform` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} MessagePack scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} (MessagePack)", scenario.schema_path.display());
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema (new_from_msgpack)
        let parse_start = Instant::now();
        
        let schema_msgpack = fs::read(&scenario.schema_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
        
        println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
        
        let mut eval = JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e));
        
        let parse_time = parse_start.elapsed();
        println!("  📝 Parse (msgpack): {:?}", parse_time);
        
        // Step 2: Evaluate
        let eval_start = Instant::now();
        
        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parse time: {:?}", total_parse_time);
    println!("Total eval time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parse: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Eval: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("Comparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/benchmark.rs (line 291)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("benchmark");
    
    let mut iterations = 1usize;
    let mut scenario_filter: Option<String> = None;
    let mut show_cpu_info = false;
    let mut use_parsed_schema = false;
    let mut concurrent_count: Option<usize> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--cpu-info" {
            show_cpu_info = true;
        } else if arg == "--parsed" {
            use_parsed_schema = true;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if arg == "--concurrent" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => concurrent_count = Some(n),
                _ => {
                    eprintln!("Error: concurrent count must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if arg == "-i" || arg == "--iterations" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => iterations = n,
                _ => {
                    eprintln!("Error: iterations must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Benchmark\n");
    
    // Show CPU info if requested or if running benchmarks
    if show_cpu_info || iterations > 1 || concurrent_count.is_some() {
        common::print_cpu_info();
    }
    
    if use_parsed_schema {
        println!("📦 Mode: ParsedSchema (parse once, reuse for all iterations)\n");
    }
    
    if let Some(count) = concurrent_count {
        println!("🔀 Concurrent evaluations: {} threads\n", count);
    } else if iterations > 1 {
        println!("🔄 Iterations per scenario: {}\n", iterations);
    }
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }

    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        println!("Running evaluation...\n");

        let (parse_time, eval_time, evaluated_schema, eval, iteration_times) = if use_parsed_schema {
            // ParsedSchema mode: parse once, reuse for all iterations/threads
            let start_time = Instant::now();
            
            let parsed_schema = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                    .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                Arc::new(ParsedSchema::parse(&schema_str)
                    .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
            };
            
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            // Concurrent mode with ParsedSchema
            if let Some(thread_count) = concurrent_count {
                use std::thread;
                
                let eval_start = Instant::now();
                let mut handles = vec![];
                
                for thread_id in 0..thread_count {
                    let parsed_clone = parsed_schema.clone();
                    let data_str_clone = data_str.clone();
                    let iter_count = iterations;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        for _ in 0..iter_count {
                            let iter_start = Instant::now();
                            let mut eval_instance = JSONEval::with_parsed_schema(
                                parsed_clone.clone(),
                                Some("{}"),
                                Some(&data_str_clone)
                            ).unwrap();
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None).unwrap();
                            last_schema = eval_instance.get_evaluated_schema(false);
                            thread_times.push(iter_start.elapsed());
                        }
                        
                        (thread_times, last_schema, thread_id)
                    });
                    handles.push(handle);
                }
                
                let mut all_iteration_times = Vec::new();
                let mut evaluated_schema = Value::Null;
                
                for handle in handles {
                    let (thread_times, thread_schema, thread_id) = handle.join().unwrap();
                    println!("  Thread {} completed {} iterations", thread_id, thread_times.len());
                    all_iteration_times.extend(thread_times);
                    evaluated_schema = thread_schema; // Use last thread's result
                }
                
                let eval_time = eval_start.elapsed();
                
                // Create a temp eval for metadata export
                let temp_eval = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                (parse_time, eval_time, evaluated_schema, temp_eval, all_iteration_times)
            } else {
                // Sequential iterations with ParsedSchema
                let eval_start = Instant::now();
                let mut evaluated_schema = Value::Null;
                let mut iteration_times = Vec::with_capacity(iterations);
                let mut eval_instance = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                for iter in 0..iterations {
                    let iter_start = Instant::now();
                    eval_instance.evaluate(&data_str, Some("{}"), None)
                        .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                    evaluated_schema = eval_instance.get_evaluated_schema(false);
                    iteration_times.push(iter_start.elapsed());
                    
                    if iterations > 1 && (iter + 1) % 10 == 0 {
                        print!(".");
                        if (iter + 1) % 50 == 0 {
                            println!(" {}/{}", iter + 1, iterations);
                        }
                    }
                }
                
                if iterations > 1 && iterations % 50 != 0 {
                    println!(" {}/{}", iterations, iterations);
                }
                
                let eval_time = eval_start.elapsed();
                (parse_time, eval_time, evaluated_schema, eval_instance, iteration_times)
            }
        } else {
            // Traditional mode: parse and create JSONEval each time
            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                JSONEval::new(&schema_str, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
            };
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            let eval_start = Instant::now();
            let mut evaluated_schema = Value::Null;
            let mut iteration_times = Vec::with_capacity(iterations);
            
            for iter in 0..iterations {
                let iter_start = Instant::now();
                eval.evaluate(&data_str, Some("{}"), None)
                    .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                evaluated_schema = eval.get_evaluated_schema(false);
                iteration_times.push(iter_start.elapsed());
                
                if iterations > 1 && (iter + 1) % 10 == 0 {
                    print!(".");
                    if (iter + 1) % 50 == 0 {
                        println!(" {}/{}", iter + 1, iterations);
                    }
                }
            }
            
            if iterations > 1 && iterations % 50 != 0 {
                println!(" {}/{}", iterations, iterations);
            }
            
            let eval_time = eval_start.elapsed();
            (parse_time, eval_time, evaluated_schema, eval, iteration_times)
        };
        
        // Calculate statistics
        let total_iterations = iteration_times.len();
        if total_iterations == 1 {
            println!("  Evaluation: {:?}", eval_time);
        } else {
            let avg_time = eval_time / total_iterations as u32;
            let min_time = iteration_times.iter().min().unwrap();
            let max_time = iteration_times.iter().max().unwrap();
            
            println!("  Total evaluation time: {:?}", eval_time);
            println!("  Total iterations: {}", total_iterations);
            println!("  Average per iteration: {:?}", avg_time);
            println!("  Min: {:?} | Max: {:?}", min_time, max_time);
            
            // Show cache statistics
            let cache_stats = eval.cache_stats();
            println!("  Cache: {} entries, {} hits, {} misses ({:.1}% hit rate)",
                cache_stats.entries,
                cache_stats.hits,
                cache_stats.misses,
                cache_stats.hit_rate * 100.0
            );
        }

        let total_time = parse_time + eval_time;
        println!("⏱️  Execution time: {:?}\n", total_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        // Track statistics
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary statistics
    if successful_scenarios > 0 {
        println!("\n{}", "=".repeat(50));
        println!("📊 Summary Statistics");
        println!("{}", "=".repeat(50));
        println!("Total scenarios run: {}", successful_scenarios);
        println!("Total parsing time: {:?}", total_parse_time);
        println!("Total evaluation time: {:?}", total_eval_time);
        println!("Total time: {:?}", total_parse_time + total_eval_time);
        
        if successful_scenarios > 1 {
            println!("\nAverage per scenario:");
            println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
            println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
        }
        
        if enable_comparison {
            println!("\nComparison failures: {}", comparison_failures);
        }
        
        println!("\n✅ All scenarios completed successfully!\n");
    }
}

pub fn with_parsed_schema( parsed: Arc<ParsedSchema>, context: Option<&str>, data: Option<&str>, ) -> Result<Self, String>

Create a new JSONEval instance from a pre-parsed ParsedSchema

This enables schema caching: parse once, reuse across multiple evaluations with different data/context.

Arguments

• parsed - Arc-wrapped pre-parsed schema (can be cloned and cached)
• context - Optional JSON context string
• data - Optional JSON data string

Returns

A Result containing the JSONEval instance or an error

Example

use std::sync::Arc;

// Parse schema once and wrap in Arc for caching
let parsed = Arc::new(ParsedSchema::parse(schema_str)?);
cache.insert(schema_key, parsed.clone());

// Reuse across multiple evaluations (Arc::clone is cheap)
let eval1 = JSONEval::with_parsed_schema(parsed.clone(), Some(context1), Some(data1))?;
let eval2 = JSONEval::with_parsed_schema(parsed.clone(), Some(context2), Some(data2))?;

Examples found in repository

examples/cache_demo.rs (line 73)

fn demo_local_cache() -> Result<(), Box<dyn std::error::Error>> {
    println!("📦 Example 1: Local Cache Instance");
    println!("Creating a dedicated cache for this application...\n");
    
    let cache = ParsedSchemaCache::new();
    
    // Simple schema
    let schema_json = r#"{
        "$params": {
            "rate": { "type": "number" }
        },
        "result": {
            "type": "number",
            "title": "Calculated Result",
            "$evaluation": {
                "logic": { "*": [{"var": "$rate"}, 100] }
            }
        }
    }"#;
    
    // Parse and cache with a custom key
    println!("📝 Parsing schema and caching with key 'calculation-v1'...");
    let parsed = ParsedSchema::parse(schema_json)?;
    cache.insert("calculation-v1".to_string(), Arc::new(parsed));
    
    println!("✅ Schema cached successfully");
    println!("   Cache size: {} entries", cache.len());
    println!("   Keys: {:?}\n", cache.keys());
    
    // Retrieve and use cached schema
    println!("🔍 Retrieving cached schema...");
    if let Some(cached_schema) = cache.get("calculation-v1") {
        println!("✅ Retrieved from cache");
        
        // Create JSONEval from cached ParsedSchema
        let mut eval = JSONEval::with_parsed_schema(cached_schema, Some(r#"{"rate": 1.5}"#), None)?;
        eval.evaluate("{}", None, None)?;
        
        let evaluated = eval.get_evaluated_schema(false);
        let result = evaluated.pointer("/result")
            .and_then(|v| v.as_f64())
            .unwrap_or(0.0);
        println!("   Evaluation result: {}\n", result);
    }
    
    // Check cache stats
    let stats = cache.stats();
    println!("📊 Cache Statistics: {}", stats);
    
    // Remove entry
    println!("\n🗑️  Removing 'calculation-v1' from cache...");
    cache.remove("calculation-v1");
    println!("   Cache size after removal: {}", cache.len());
    
    Ok(())
}

fn demo_global_cache() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌍 Example 2: Global Cache Instance");
    println!("Using the built-in PARSED_SCHEMA_CACHE...\n");
    
    let schema_json = r#"{
        "$params": {
            "x": { "type": "number" },
            "y": { "type": "number" }
        },
        "sum": {
            "type": "number",
            "$evaluation": { "+": [{"var": "$x"}, {"var": "$y"}] }
        }
    }"#;
    
    // Use global cache
    println!("📝 Caching schema globally with key 'math-operations'...");
    let parsed = ParsedSchema::parse(schema_json)?;
    PARSED_SCHEMA_CACHE.insert("math-operations".to_string(), Arc::new(parsed));
    
    println!("✅ Schema cached globally");
    println!("   Global cache size: {}\n", PARSED_SCHEMA_CACHE.len());
    
    // Access from anywhere in the application
    simulate_another_function()?;
    
    // Clean up
    println!("\n🧹 Clearing global cache...");
    PARSED_SCHEMA_CACHE.clear();
    println!("   Global cache size: {}", PARSED_SCHEMA_CACHE.len());
    
    Ok(())
}

fn simulate_another_function() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔄 In another function, accessing global cache...");
    
    if let Some(cached) = PARSED_SCHEMA_CACHE.get("math-operations") {
        println!("✅ Retrieved schema from global cache");
        
        let mut eval = JSONEval::with_parsed_schema(cached, Some(r#"{"x": 10, "y": 20}"#), None)?;
        eval.evaluate("{}", None, None)?;
        
        let evaluated = eval.get_evaluated_schema(false);
        let sum = evaluated.pointer("/sum")
            .and_then(|v| v.as_f64())
            .unwrap_or(0.0);
        println!("   Result: {}", sum);
    }
    
    Ok(())
}

fn demo_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ Example 3: Performance Comparison");
    println!("Comparing cached vs non-cached schema usage...\n");
    
    let schema_json = r#"{
        "$params": {
            "value": { "type": "number" }
        },
        "doubled": {
            "type": "number",
            "$evaluation": { "*": [{"var": "$value"}, 2] }
        },
        "tripled": {
            "type": "number",
            "$evaluation": { "*": [{"var": "$value"}, 3] }
        }
    }"#;
    
    let iterations = 100;
    
    // WITHOUT CACHE: Parse schema every time
    println!("🐌 Without cache (parse + evaluate each time):");
    let start = Instant::now();
    for i in 0..iterations {
        let context = format!(r#"{{"value": {}}}"#, i);
        let mut eval = JSONEval::new(schema_json, Some(&context), None)?;
        eval.evaluate("{}", None, None)?;
    }
    let without_cache = start.elapsed();
    println!("   Time: {:?}", without_cache);
    println!("   Avg per iteration: {:?}\n", without_cache / iterations);
    
    // WITH CACHE: Parse once, evaluate many times
    println!("🚀 With cache (parse once, reuse for all evaluations):");
    let cache = ParsedSchemaCache::new();
    
    // Parse once
    let parse_start = Instant::now();
    let parsed = ParsedSchema::parse(schema_json)?;
    cache.insert("perf-test".to_string(), Arc::new(parsed));
    let parse_time = parse_start.elapsed();
    
    // Evaluate many times
    let eval_start = Instant::now();
    for i in 0..iterations {
        if let Some(cached) = cache.get("perf-test") {
            let context = format!(r#"{{"value": {}}}"#, i);
            let mut eval = JSONEval::with_parsed_schema(cached.clone(), Some(&context), None)?;
            eval.evaluate("{}", None, None)?;
        }
    }
    let eval_time = eval_start.elapsed();
    let with_cache = parse_time + eval_time;
    
    println!("   Parse time: {:?}", parse_time);
    println!("   Eval time: {:?}", eval_time);
    println!("   Total time: {:?}", with_cache);
    println!("   Avg per iteration: {:?}\n", eval_time / iterations);
    
    let speedup = without_cache.as_secs_f64() / with_cache.as_secs_f64();
    println!("📈 Speedup: {:.2}x faster", speedup);
    
    Ok(())
}

examples/basic_parsed.rs (lines 143-147)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("basic_parsed");
    
    let mut scenario_filter: Option<String> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Basic Example (ParsedSchema)\n");
    println!("📦 Using Arc<ParsedSchema> for efficient caching\n");
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }
    
    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        // Step 1: Parse schema once
        let parse_start = Instant::now();
        let parsed_schema = if scenario.is_msgpack {
            let schema_msgpack = fs::read(&scenario.schema_path)
                .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
            println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
            Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
        } else {
            let schema_str = fs::read_to_string(&scenario.schema_path)
                .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
            Arc::new(ParsedSchema::parse(&schema_str)
                .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
        };
        let parse_time = parse_start.elapsed();
        println!("  📝 Schema parsing: {:?}", parse_time);
        
        // Step 2: Create JSONEval from ParsedSchema (reuses compiled logic)
        let eval_start = Instant::now();
        let mut eval = JSONEval::with_parsed_schema(
            parsed_schema.clone(),  // Arc::clone is cheap!
            Some("{}"),
            Some(&data_str)
        ).unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e));

        eval.evaluate(&data_str, Some("{}"), None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
        
        let evaluated_schema = eval.get_evaluated_schema(false);
        let eval_time = eval_start.elapsed();
        
        println!("  ⚡ Eval: {:?}", eval_time);
        println!("  ⏱️  Total: {:?}\n", parse_time + eval_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        // Save results
        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("evaluations".to_string(), serde_json::to_value(&*eval.evaluations).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary
    println!("{}", "=".repeat(50));
    println!("📊 Summary");
    println!("{}", "=".repeat(50));
    println!("Total scenarios run: {}", successful_scenarios);
    println!("Total parsing time: {:?}", total_parse_time);
    println!("Total evaluation time: {:?}", total_eval_time);
    println!("Total time: {:?}", total_parse_time + total_eval_time);
    
    if successful_scenarios > 1 {
        println!("\nAverage per scenario:");
        println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
        println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
    }
    
    if enable_comparison {
        println!("\nComparison failures: {}", comparison_failures);
    }
    
    println!("\n✅ All scenarios completed!\n");
}

examples/benchmark.rs (lines 215-219)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("benchmark");
    
    let mut iterations = 1usize;
    let mut scenario_filter: Option<String> = None;
    let mut show_cpu_info = false;
    let mut use_parsed_schema = false;
    let mut concurrent_count: Option<usize> = None;
    let mut enable_comparison = false;
    let mut show_timing = false;
    let mut i = 1;
    
    // Parse arguments
    while i < args.len() {
        let arg = &args[i];
        
        if arg == "-h" || arg == "--help" {
            print_help(program_name);
            return;
        } else if arg == "--cpu-info" {
            show_cpu_info = true;
        } else if arg == "--parsed" {
            use_parsed_schema = true;
        } else if arg == "--compare" {
            enable_comparison = true;
        } else if arg == "--timing" {
            show_timing = true;
        } else if arg == "--concurrent" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => concurrent_count = Some(n),
                _ => {
                    eprintln!("Error: concurrent count must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if arg == "-i" || arg == "--iterations" {
            if i + 1 >= args.len() {
                eprintln!("Error: {} requires a value", arg);
                print_help(program_name);
                return;
            }
            i += 1;
            match args[i].parse::<usize>() {
                Ok(n) if n > 0 => iterations = n,
                _ => {
                    eprintln!("Error: iterations must be a positive integer, got '{}'", args[i]);
                    return;
                }
            }
        } else if !arg.starts_with('-') {
            scenario_filter = Some(arg.clone());
        } else {
            eprintln!("Error: unknown option '{}'", arg);
            print_help(program_name);
            return;
        }
        
        i += 1;
    }
    
    println!("\n🚀 JSON Evaluation - Benchmark\n");
    
    // Show CPU info if requested or if running benchmarks
    if show_cpu_info || iterations > 1 || concurrent_count.is_some() {
        common::print_cpu_info();
    }
    
    if use_parsed_schema {
        println!("📦 Mode: ParsedSchema (parse once, reuse for all iterations)\n");
    }
    
    if let Some(count) = concurrent_count {
        println!("🔀 Concurrent evaluations: {} threads\n", count);
    } else if iterations > 1 {
        println!("🔄 Iterations per scenario: {}\n", iterations);
    }
    
    if enable_comparison {
        println!("🔍 Comparison: enabled");
    }
    if show_timing {
        println!("⏱️  Internal timing: enabled");
    }
    if enable_comparison || show_timing {
        println!();
    }

    let samples_dir = Path::new("samples");
    let mut scenarios = common::discover_scenarios(samples_dir);
    
    // Filter scenarios if a filter is provided
    if let Some(ref filter) = scenario_filter {
        scenarios.retain(|s| s.name.contains(filter));
        println!("📋 Filtering scenarios matching: '{}'\n", filter);
    }

    if scenarios.is_empty() {
        if let Some(filter) = scenario_filter {
            println!(
                "ℹ️  No scenarios found matching '{}' in `{}`.",
                filter,
                samples_dir.display()
            );
        } else {
            println!(
                "ℹ️  No scenarios discovered in `{}`. Add files like `name.json` and `name-data.json`.",
                samples_dir.display()
            );
        }
        return;
    }
    
    println!("📊 Found {} scenario(s)\n", scenarios.len());

    let mut total_parse_time = std::time::Duration::ZERO;
    let mut total_eval_time = std::time::Duration::ZERO;
    let mut successful_scenarios = 0;
    let mut comparison_failures = 0;

    for scenario in &scenarios {
        println!("==============================");
        println!("Scenario: {}", scenario.name);
        println!("Schema: {} ({})", 
            scenario.schema_path.display(),
            if scenario.is_msgpack { "MessagePack" } else { "JSON" }
        );
        println!("Data: {}\n", scenario.data_path.display());

        // Clear timing data from previous scenarios
        if show_timing {
            json_eval_rs::enable_timing();
            json_eval_rs::clear_timing_data();
        }

        let data_str = fs::read_to_string(&scenario.data_path)
            .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.data_path.display(), e));

        println!("Running evaluation...\n");

        let (parse_time, eval_time, evaluated_schema, eval, iteration_times) = if use_parsed_schema {
            // ParsedSchema mode: parse once, reuse for all iterations/threads
            let start_time = Instant::now();
            
            let parsed_schema = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                Arc::new(ParsedSchema::parse_msgpack(&schema_msgpack)
                    .unwrap_or_else(|e| panic!("failed to parse MessagePack schema: {}", e)))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                Arc::new(ParsedSchema::parse(&schema_str)
                    .unwrap_or_else(|e| panic!("failed to parse schema: {}", e)))
            };
            
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            // Concurrent mode with ParsedSchema
            if let Some(thread_count) = concurrent_count {
                use std::thread;
                
                let eval_start = Instant::now();
                let mut handles = vec![];
                
                for thread_id in 0..thread_count {
                    let parsed_clone = parsed_schema.clone();
                    let data_str_clone = data_str.clone();
                    let iter_count = iterations;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        for _ in 0..iter_count {
                            let iter_start = Instant::now();
                            let mut eval_instance = JSONEval::with_parsed_schema(
                                parsed_clone.clone(),
                                Some("{}"),
                                Some(&data_str_clone)
                            ).unwrap();
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None).unwrap();
                            last_schema = eval_instance.get_evaluated_schema(false);
                            thread_times.push(iter_start.elapsed());
                        }
                        
                        (thread_times, last_schema, thread_id)
                    });
                    handles.push(handle);
                }
                
                let mut all_iteration_times = Vec::new();
                let mut evaluated_schema = Value::Null;
                
                for handle in handles {
                    let (thread_times, thread_schema, thread_id) = handle.join().unwrap();
                    println!("  Thread {} completed {} iterations", thread_id, thread_times.len());
                    all_iteration_times.extend(thread_times);
                    evaluated_schema = thread_schema; // Use last thread's result
                }
                
                let eval_time = eval_start.elapsed();
                
                // Create a temp eval for metadata export
                let temp_eval = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                (parse_time, eval_time, evaluated_schema, temp_eval, all_iteration_times)
            } else {
                // Sequential iterations with ParsedSchema
                let eval_start = Instant::now();
                let mut evaluated_schema = Value::Null;
                let mut iteration_times = Vec::with_capacity(iterations);
                let mut eval_instance = JSONEval::with_parsed_schema(
                    parsed_schema.clone(),
                    Some("{}"),
                    Some(&data_str)
                ).unwrap();
                
                for iter in 0..iterations {
                    let iter_start = Instant::now();
                    eval_instance.evaluate(&data_str, Some("{}"), None)
                        .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                    evaluated_schema = eval_instance.get_evaluated_schema(false);
                    iteration_times.push(iter_start.elapsed());
                    
                    if iterations > 1 && (iter + 1) % 10 == 0 {
                        print!(".");
                        if (iter + 1) % 50 == 0 {
                            println!(" {}/{}", iter + 1, iterations);
                        }
                    }
                }
                
                if iterations > 1 && iterations % 50 != 0 {
                    println!(" {}/{}", iterations, iterations);
                }
                
                let eval_time = eval_start.elapsed();
                (parse_time, eval_time, evaluated_schema, eval_instance, iteration_times)
            }
        } else {
            // Traditional mode: parse and create JSONEval each time
            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                let schema_msgpack = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", schema_msgpack.len());
                JSONEval::new_from_msgpack(&schema_msgpack, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                let schema_str = fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                JSONEval::new(&schema_str, None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
            };
            let parse_time = start_time.elapsed();
            println!("  Schema parsing & compilation: {:?}", parse_time);
            
            let eval_start = Instant::now();
            let mut evaluated_schema = Value::Null;
            let mut iteration_times = Vec::with_capacity(iterations);
            
            for iter in 0..iterations {
                let iter_start = Instant::now();
                eval.evaluate(&data_str, Some("{}"), None)
                    .unwrap_or_else(|e| panic!("evaluation failed: {}", e));
                evaluated_schema = eval.get_evaluated_schema(false);
                iteration_times.push(iter_start.elapsed());
                
                if iterations > 1 && (iter + 1) % 10 == 0 {
                    print!(".");
                    if (iter + 1) % 50 == 0 {
                        println!(" {}/{}", iter + 1, iterations);
                    }
                }
            }
            
            if iterations > 1 && iterations % 50 != 0 {
                println!(" {}/{}", iterations, iterations);
            }
            
            let eval_time = eval_start.elapsed();
            (parse_time, eval_time, evaluated_schema, eval, iteration_times)
        };
        
        // Calculate statistics
        let total_iterations = iteration_times.len();
        if total_iterations == 1 {
            println!("  Evaluation: {:?}", eval_time);
        } else {
            let avg_time = eval_time / total_iterations as u32;
            let min_time = iteration_times.iter().min().unwrap();
            let max_time = iteration_times.iter().max().unwrap();
            
            println!("  Total evaluation time: {:?}", eval_time);
            println!("  Total iterations: {}", total_iterations);
            println!("  Average per iteration: {:?}", avg_time);
            println!("  Min: {:?} | Max: {:?}", min_time, max_time);
            
            // Show cache statistics
            let cache_stats = eval.cache_stats();
            println!("  Cache: {} entries, {} hits, {} misses ({:.1}% hit rate)",
                cache_stats.entries,
                cache_stats.hits,
                cache_stats.misses,
                cache_stats.hit_rate * 100.0
            );
        }

        let total_time = parse_time + eval_time;
        println!("⏱️  Execution time: {:?}\n", total_time);
        
        // Print detailed timing breakdown if --timing flag is set
        if show_timing {
            json_eval_rs::print_timing_summary();
        }
        
        // Track statistics
        total_parse_time += parse_time;
        total_eval_time += eval_time;
        successful_scenarios += 1;

        let evaluated_path = samples_dir.join(format!("{}-evaluated-schema.json", scenario.name));
        let parsed_path = samples_dir.join(format!("{}-parsed-schema.json", scenario.name));

        fs::write(&evaluated_path, common::pretty_json(&evaluated_schema))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", evaluated_path.display(), e));

        let mut metadata_obj = Map::new();
        metadata_obj.insert("dependencies".to_string(), serde_json::to_value(&*eval.dependencies).unwrap());
        metadata_obj.insert("sorted_evaluations".to_string(), serde_json::to_value(&*eval.sorted_evaluations).unwrap());

        fs::write(&parsed_path, common::pretty_json(&Value::Object(metadata_obj)))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", parsed_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}\n", parsed_path.display());

        // Optional comparison
        if enable_comparison {
            if let Some(comp_path) = &scenario.comparison_path {
                if common::compare_with_expected(&evaluated_schema, comp_path).is_err() {
                    comparison_failures += 1;
                }
                println!();
            }
        }
    }
    
    // Print summary statistics
    if successful_scenarios > 0 {
        println!("\n{}", "=".repeat(50));
        println!("📊 Summary Statistics");
        println!("{}", "=".repeat(50));
        println!("Total scenarios run: {}", successful_scenarios);
        println!("Total parsing time: {:?}", total_parse_time);
        println!("Total evaluation time: {:?}", total_eval_time);
        println!("Total time: {:?}", total_parse_time + total_eval_time);
        
        if successful_scenarios > 1 {
            println!("\nAverage per scenario:");
            println!("  Parsing: {:?}", total_parse_time / successful_scenarios as u32);
            println!("  Evaluation: {:?}", total_eval_time / successful_scenarios as u32);
        }
        
        if enable_comparison {
            println!("\nComparison failures: {}", comparison_failures);
        }
        
        println!("\n✅ All scenarios completed successfully!\n");
    }
}

pub fn reload_schema( &mut self, schema: &str, context: Option<&str>, data: Option<&str>, ) -> Result<(), String>

pub fn set_timezone_offset(&mut self, offset_minutes: Option<i32>)

Set the timezone offset for datetime operations (TODAY, NOW)

This method updates the RLogic engine configuration with a new timezone offset. The offset will be applied to all subsequent datetime evaluations.

Arguments

• offset_minutes - Timezone offset in minutes from UTC (e.g., 420 for UTC+7, -300 for UTC-5) Pass None to reset to UTC (no offset)

Example

let mut eval = JSONEval::new(schema, None, None)?;

// Set to UTC+7 (Jakarta, Bangkok)
eval.set_timezone_offset(Some(420));

// Reset to UTC
eval.set_timezone_offset(None);

pub fn reload_schema_msgpack( &mut self, schema_msgpack: &[u8], context: Option<&str>, data: Option<&str>, ) -> Result<(), String>

Reload schema from MessagePack-encoded bytes

Arguments

• schema_msgpack - MessagePack-encoded schema bytes
• context - Optional context data JSON string
• data - Optional initial data JSON string

Returns

A Result indicating success or an error message

pub fn reload_schema_parsed( &mut self, parsed: Arc<ParsedSchema>, context: Option<&str>, data: Option<&str>, ) -> Result<(), String>

Reload schema from a cached ParsedSchema

This is the most efficient way to reload as it reuses pre-parsed schema compilation.

Arguments

• parsed - Arc reference to a cached ParsedSchema
• context - Optional context data JSON string
• data - Optional initial data JSON string

Returns

A Result indicating success or an error message

pub fn reload_schema_from_cache( &mut self, cache_key: &str, context: Option<&str>, data: Option<&str>, ) -> Result<(), String>

Reload schema from ParsedSchemaCache using a cache key

This is the recommended way for cross-platform cached schema reloading.

Arguments

• cache_key - Key to lookup in the global ParsedSchemaCache
• context - Optional context data JSON string
• data - Optional initial data JSON string

Returns

A Result indicating success or an error message

impl JSONEval

pub fn resolve_layout(&mut self, evaluate: bool)

Resolve layout references with optional evaluation

impl JSONEval

pub fn run_logic( &mut self, logic_id: CompiledLogicId, data: Option<&Value>, context: Option<&Value>, ) -> Result<Value, String>

Run pre-compiled logic against current data

pub fn compile_logic(&self, logic_str: &str) -> Result<CompiledLogicId, String>

Compile a logic expression from a JSON string and store it globally

pub fn compile_logic_value( &self, logic: &Value, ) -> Result<CompiledLogicId, String>

Compile a logic expression from a Value and store it globally

pub fn compile_and_run_logic( &mut self, logic_str: &str, data: Option<&str>, context: Option<&str>, ) -> Result<Value, String>

Compile and run logic in one go (convenience method)

impl JSONEval

pub fn evaluate_subform( &mut self, subform_path: &str, data: &str, context: Option<&str>, paths: Option<&[String]>, ) -> Result<(), String>

Evaluate a subform with data Evaluate a subform with data and optional selective paths

pub fn validate_subform( &mut self, subform_path: &str, data: &str, context: Option<&str>, paths: Option<&[String]>, ) -> Result<ValidationResult, String>

Validate subform data against its schema rules

pub fn evaluate_dependents_subform( &mut self, subform_path: &str, changed_paths: &[String], data: Option<&str>, context: Option<&str>, re_evaluate: bool, ) -> Result<Value, String>

Evaluate dependents in subform when a field changes

pub fn resolve_layout_subform( &mut self, subform_path: &str, evaluate: bool, ) -> Result<(), String>

Resolve layout for subform

pub fn get_evaluated_schema_subform( &mut self, subform_path: &str, resolve_layout: bool, ) -> Value

Get evaluated schema from subform

pub fn get_schema_value_subform(&mut self, subform_path: &str) -> Value

Get schema value from subform (all .value fields)

pub fn get_evaluated_schema_without_params_subform( &mut self, subform_path: &str, resolve_layout: bool, ) -> Value

Get evaluated schema without $params from subform

pub fn get_evaluated_schema_by_path_subform( &mut self, subform_path: &str, schema_path: &str, skip_layout: bool, ) -> Option<Value>

Get evaluated schema by specific path from subform

pub fn get_evaluated_schema_by_paths_subform( &mut self, subform_path: &str, schema_paths: &[String], skip_layout: bool, format: Option<ReturnFormat>, ) -> Value

Get evaluated schema by multiple paths from subform

pub fn get_schema_by_path_subform( &self, subform_path: &str, schema_path: &str, ) -> Option<Value>

Get schema by specific path from subform

pub fn get_schema_by_paths_subform( &self, subform_path: &str, schema_paths: &[String], format: Option<ReturnFormat>, ) -> Value

Get schema by multiple paths from subform

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

Get list of available subform paths

pub fn has_subform(&self, subform_path: &str) -> bool

Check if a subform exists at the given path

impl JSONEval

pub fn validate( &mut self, data: &str, context: Option<&str>, paths: Option<&[String]>, ) -> Result<ValidationResult, String>

Validate data against schema rules

Trait Implementations

impl Clone for JSONEval

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.