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>>

tables: Arc<IndexMap<String, Value>>

table_metadata: Arc<IndexMap<String, TableMetadata>>

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

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

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

rules_evaluations: Arc<Vec<String>>

fields_with_rules: Arc<Vec<String>>

others_evaluations: Arc<Vec<String>>

value_evaluations: Arc<Vec<String>>

layout_paths: Arc<Vec<String>>

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

subforms: IndexMap<String, Box<JSONEval>>

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

conditional_hidden_fields: Arc<Vec<String>>

conditional_readonly_fields: Arc<Vec<String>>

context: Value

data: Value

evaluated_schema: Value

eval_data: EvalData

eval_cache: EvalCache

cache_enabled: bool

Implementations

impl JSONEval

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

Check if a dependency should be part of the cache key Check if a dependency should be cached Caches everything except keys starting with $ (except $context)

pub fn purge_cache_for_changed_data_with_comparison( &self, old_data: &Value, new_data: &Value, )

Compares old vs new values by deep diffing and purges affected entries

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

Selectively purge cache entries that depend on changed data paths Finds all eval_keys that depend on the changed paths and removes them Selectively purge cache entries that depend on changed data paths Simpler version without value comparison for cases where we don’t have old data

pub fn purge_cache_for_context_change(&self)

Purge cache entries affected by context changes Purge cache entries that depend on context

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, 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, 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, None).unwrap();
        
        println!("Cache size after evaluation: {}", eval.cache_len());
        println!("\n✅ Cache can be toggled as needed!");
    }
}

examples/benchmark.rs (line 393)

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 use_cache = 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 == "--cache" {
            use_cache = 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 use_cache {
        println!("♻️  Mode: Cache (reuse JSONEval instance across 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 thread_use_cache = use_cache;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        let mut eval_instance = JSONEval::with_parsed_schema(
                            parsed_clone.clone(),
                            Some("{}"),
                            Some(&data_str_clone)
                        ).unwrap();
                        
                        for iter in 0..iter_count {
                            let iter_start = Instant::now();
                            
                            if !thread_use_cache && iter > 0 {
                                eval_instance = JSONEval::with_parsed_schema(
                                    parsed_clone.clone(),
                                    Some("{}"),
                                    Some(&data_str_clone)
                                ).unwrap();
                            }
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None, 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();
                    
                    if !use_cache && iter > 0 {
                        eval_instance = JSONEval::with_parsed_schema(
                            parsed_schema.clone(),
                            Some("{}"),
                            Some(&data_str)
                        ).unwrap();
                    }
                    
                    eval_instance.evaluate(&data_str, Some("{}"), None, 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 schema_msgpack = if scenario.is_msgpack {
                let bytes = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", bytes.len());
                Some(bytes)
            } else {
                None
            };
            
            let schema_str = if !scenario.is_msgpack {
                Some(fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e)))
            } else {
                None
            };

            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                JSONEval::new(schema_str.as_ref().unwrap(), 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();
                
                if !use_cache && iter > 0 {
                    eval = if scenario.is_msgpack {
                        JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
                    } else {
                        JSONEval::new(schema_str.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
                    };
                }
                
                eval.evaluate(&data_str, Some("{}"), None, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, token: Option<&CancellationToken>, canceled_paths: Option<&mut Vec<String>>, ) -> 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]>, token: Option<&CancellationToken>, ) -> 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, 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, 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, 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, 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, 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, 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, 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(false);
        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, 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, 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, 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(false).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, 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_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, 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/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, None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));

        // Step 3: Validate
        let validation_start = Instant::now();
        let validation_result = eval.validate(&data_str, None, None, None)
            .unwrap_or_else(|e| panic!("validation failed: {}", e));
        let validation_time = validation_start.elapsed();
        println!("  🛡️ Validate: {:?}", validation_time);
        
        // Legacy behavior: get_evaluated_schema takes skip_layout: bool
        // We pass false to ensure layout IS resolved
        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));
        let validation_path = samples_dir.join(format!("{}-validation.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));

        let validation_value = serde_json::to_value(&validation_result)
            .unwrap_or_else(|e| panic!("failed to serialize validation result: {}", e));
        fs::write(&validation_path, common::pretty_json(&validation_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", validation_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}", value_path.display());
        println!("  - {}\n", validation_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");
}

Additional examples can be found in:

• examples/benchmark.rs

impl JSONEval

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

Get the evaluated schema with optional layout resolution.

Arguments

• skip_layout - Whether to skip layout resolution.

Returns

The evaluated schema as a JSON value.

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, 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, 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(false);
        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, 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, 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, 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(false).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, 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_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, 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/basic.rs (line 151)

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, None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));

        // Step 3: Validate
        let validation_start = Instant::now();
        let validation_result = eval.validate(&data_str, None, None, None)
            .unwrap_or_else(|e| panic!("validation failed: {}", e));
        let validation_time = validation_start.elapsed();
        println!("  🛡️ Validate: {:?}", validation_time);
        
        // Legacy behavior: get_evaluated_schema takes skip_layout: bool
        // We pass false to ensure layout IS resolved
        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));
        let validation_path = samples_dir.join(format!("{}-validation.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));

        let validation_value = serde_json::to_value(&validation_result)
            .unwrap_or_else(|e| panic!("failed to serialize validation result: {}", e));
        fs::write(&validation_path, common::pretty_json(&validation_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", validation_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}", value_path.display());
        println!("  - {}\n", validation_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 240)

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 use_cache = 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 == "--cache" {
            use_cache = 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 use_cache {
        println!("♻️  Mode: Cache (reuse JSONEval instance across 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 thread_use_cache = use_cache;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        let mut eval_instance = JSONEval::with_parsed_schema(
                            parsed_clone.clone(),
                            Some("{}"),
                            Some(&data_str_clone)
                        ).unwrap();
                        
                        for iter in 0..iter_count {
                            let iter_start = Instant::now();
                            
                            if !thread_use_cache && iter > 0 {
                                eval_instance = JSONEval::with_parsed_schema(
                                    parsed_clone.clone(),
                                    Some("{}"),
                                    Some(&data_str_clone)
                                ).unwrap();
                            }
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None, 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();
                    
                    if !use_cache && iter > 0 {
                        eval_instance = JSONEval::with_parsed_schema(
                            parsed_schema.clone(),
                            Some("{}"),
                            Some(&data_str)
                        ).unwrap();
                    }
                    
                    eval_instance.evaluate(&data_str, Some("{}"), None, 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 schema_msgpack = if scenario.is_msgpack {
                let bytes = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", bytes.len());
                Some(bytes)
            } else {
                None
            };
            
            let schema_str = if !scenario.is_msgpack {
                Some(fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e)))
            } else {
                None
            };

            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                JSONEval::new(schema_str.as_ref().unwrap(), 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();
                
                if !use_cache && iter > 0 {
                    eval = if scenario.is_msgpack {
                        JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
                    } else {
                        JSONEval::new(schema_str.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
                    };
                }
                
                eval.evaluate(&data_str, Some("{}"), None, 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_schema_value_by_path(&self, path: &str) -> Option<Value>

Get specific schema value by path

pub fn get_schema_value(&mut self) -> Value

Get all schema values (data view) Mutates internal data state by overriding with values from value evaluations This corresponds to subform.get_schema_value() usage

Examples found in repository

examples/basic.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");
    
    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, None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));

        // Step 3: Validate
        let validation_start = Instant::now();
        let validation_result = eval.validate(&data_str, None, None, None)
            .unwrap_or_else(|e| panic!("validation failed: {}", e));
        let validation_time = validation_start.elapsed();
        println!("  🛡️ Validate: {:?}", validation_time);
        
        // Legacy behavior: get_evaluated_schema takes skip_layout: bool
        // We pass false to ensure layout IS resolved
        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));
        let validation_path = samples_dir.join(format!("{}-validation.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));

        let validation_value = serde_json::to_value(&validation_result)
            .unwrap_or_else(|e| panic!("failed to serialize validation result: {}", e));
        fs::write(&validation_path, common::pretty_json(&validation_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", validation_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}", value_path.display());
        println!("  - {}\n", validation_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_schema_value_array(&self) -> Value

Get all schema values as array of path-value pairs Returns [{path: “”, value: “”}, …]

Returns

Array of objects containing path (dotted notation) and value pairs from value evaluations

pub fn get_schema_value_object(&self) -> Value

Get all schema values as object with dotted path keys Returns {path: value, …}

Returns

Flat object with dotted notation paths as keys and evaluated values

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

Get evaluated schema without $params

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

Get evaluated schema as MessagePack bytes

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

Get value from evaluated schema by path

pub fn get_evaluated_schema_by_paths( &mut self, paths: &[String], skip_layout: bool, format: Option<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: Option<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, 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, 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, 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, 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, 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(false);
        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, 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, 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, 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(false).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, None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));

        // Step 3: Validate
        let validation_start = Instant::now();
        let validation_result = eval.validate(&data_str, None, None, None)
            .unwrap_or_else(|e| panic!("validation failed: {}", e));
        let validation_time = validation_start.elapsed();
        println!("  🛡️ Validate: {:?}", validation_time);
        
        // Legacy behavior: get_evaluated_schema takes skip_layout: bool
        // We pass false to ensure layout IS resolved
        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));
        let validation_path = samples_dir.join(format!("{}-validation.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));

        let validation_value = serde_json::to_value(&validation_result)
            .unwrap_or_else(|e| panic!("failed to serialize validation result: {}", e));
        fs::write(&validation_path, common::pretty_json(&validation_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", validation_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}", value_path.display());
        println!("  - {}\n", validation_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 334)

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 use_cache = 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 == "--cache" {
            use_cache = 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 use_cache {
        println!("♻️  Mode: Cache (reuse JSONEval instance across 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 thread_use_cache = use_cache;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        let mut eval_instance = JSONEval::with_parsed_schema(
                            parsed_clone.clone(),
                            Some("{}"),
                            Some(&data_str_clone)
                        ).unwrap();
                        
                        for iter in 0..iter_count {
                            let iter_start = Instant::now();
                            
                            if !thread_use_cache && iter > 0 {
                                eval_instance = JSONEval::with_parsed_schema(
                                    parsed_clone.clone(),
                                    Some("{}"),
                                    Some(&data_str_clone)
                                ).unwrap();
                            }
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None, 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();
                    
                    if !use_cache && iter > 0 {
                        eval_instance = JSONEval::with_parsed_schema(
                            parsed_schema.clone(),
                            Some("{}"),
                            Some(&data_str)
                        ).unwrap();
                    }
                    
                    eval_instance.evaluate(&data_str, Some("{}"), None, 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 schema_msgpack = if scenario.is_msgpack {
                let bytes = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", bytes.len());
                Some(bytes)
            } else {
                None
            };
            
            let schema_str = if !scenario.is_msgpack {
                Some(fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e)))
            } else {
                None
            };

            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                JSONEval::new(schema_str.as_ref().unwrap(), 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();
                
                if !use_cache && iter > 0 {
                    eval = if scenario.is_msgpack {
                        JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
                    } else {
                        JSONEval::new(schema_str.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
                    };
                }
                
                eval.evaluate(&data_str, Some("{}"), None, 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, 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 331)

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 use_cache = 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 == "--cache" {
            use_cache = 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 use_cache {
        println!("♻️  Mode: Cache (reuse JSONEval instance across 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 thread_use_cache = use_cache;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        let mut eval_instance = JSONEval::with_parsed_schema(
                            parsed_clone.clone(),
                            Some("{}"),
                            Some(&data_str_clone)
                        ).unwrap();
                        
                        for iter in 0..iter_count {
                            let iter_start = Instant::now();
                            
                            if !thread_use_cache && iter > 0 {
                                eval_instance = JSONEval::with_parsed_schema(
                                    parsed_clone.clone(),
                                    Some("{}"),
                                    Some(&data_str_clone)
                                ).unwrap();
                            }
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None, 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();
                    
                    if !use_cache && iter > 0 {
                        eval_instance = JSONEval::with_parsed_schema(
                            parsed_schema.clone(),
                            Some("{}"),
                            Some(&data_str)
                        ).unwrap();
                    }
                    
                    eval_instance.evaluate(&data_str, Some("{}"), None, 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 schema_msgpack = if scenario.is_msgpack {
                let bytes = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", bytes.len());
                Some(bytes)
            } else {
                None
            };
            
            let schema_str = if !scenario.is_msgpack {
                Some(fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e)))
            } else {
                None
            };

            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                JSONEval::new(schema_str.as_ref().unwrap(), 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();
                
                if !use_cache && iter > 0 {
                    eval = if scenario.is_msgpack {
                        JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
                    } else {
                        JSONEval::new(schema_str.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
                    };
                }
                
                eval.evaluate(&data_str, Some("{}"), None, 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, 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, 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, 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, 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, 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 222-226)

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 use_cache = 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 == "--cache" {
            use_cache = 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 use_cache {
        println!("♻️  Mode: Cache (reuse JSONEval instance across 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 thread_use_cache = use_cache;
                    
                    let handle = thread::spawn(move || {
                        let mut thread_times = Vec::with_capacity(iter_count);
                        let mut last_schema = Value::Null;
                        
                        let mut eval_instance = JSONEval::with_parsed_schema(
                            parsed_clone.clone(),
                            Some("{}"),
                            Some(&data_str_clone)
                        ).unwrap();
                        
                        for iter in 0..iter_count {
                            let iter_start = Instant::now();
                            
                            if !thread_use_cache && iter > 0 {
                                eval_instance = JSONEval::with_parsed_schema(
                                    parsed_clone.clone(),
                                    Some("{}"),
                                    Some(&data_str_clone)
                                ).unwrap();
                            }
                            
                            eval_instance.evaluate(&data_str_clone, Some("{}"), None, 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();
                    
                    if !use_cache && iter > 0 {
                        eval_instance = JSONEval::with_parsed_schema(
                            parsed_schema.clone(),
                            Some("{}"),
                            Some(&data_str)
                        ).unwrap();
                    }
                    
                    eval_instance.evaluate(&data_str, Some("{}"), None, 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 schema_msgpack = if scenario.is_msgpack {
                let bytes = fs::read(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e));
                println!("  📦 MessagePack schema size: {} bytes", bytes.len());
                Some(bytes)
            } else {
                None
            };
            
            let schema_str = if !scenario.is_msgpack {
                Some(fs::read_to_string(&scenario.schema_path)
                    .unwrap_or_else(|e| panic!("failed to read {}: {}", scenario.schema_path.display(), e)))
            } else {
                None
            };

            let start_time = Instant::now();
            let mut eval = if scenario.is_msgpack {
                JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                    .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
            } else {
                JSONEval::new(schema_str.as_ref().unwrap(), 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();
                
                if !use_cache && iter > 0 {
                    eval = if scenario.is_msgpack {
                        JSONEval::new_from_msgpack(schema_msgpack.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval from MessagePack: {}", e))
                    } else {
                        JSONEval::new(schema_str.as_ref().unwrap(), None, Some(&data_str))
                            .unwrap_or_else(|e| panic!("failed to create JSONEval: {}", e))
                    };
                }
                
                eval.evaluate(&data_str, Some("{}"), None, 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) -> Result<(), String>

Resolve layout references with optional evaluation

Arguments

• evaluate - If true, runs evaluation before resolving layout. If false, only resolves layout.

Returns

A Result indicating success or an error message.

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]>, token: Option<&CancellationToken>, ) -> 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]>, token: Option<&CancellationToken>, ) -> 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, token: Option<&CancellationToken>, canceled_paths: Option<&mut Vec<String>>, ) -> 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 in nested object format (all .value fields).

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

Get schema values from subform as a flat array of path-value pairs.

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

Get schema values from subform as a flat object with dotted path keys.

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]>, token: Option<&CancellationToken>, ) -> Result<ValidationResult, String>

Validate data against schema rules

Examples found in repository

examples/basic.rs (line 144)

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, None)
            .unwrap_or_else(|e| panic!("evaluation failed: {}", e));

        // Step 3: Validate
        let validation_start = Instant::now();
        let validation_result = eval.validate(&data_str, None, None, None)
            .unwrap_or_else(|e| panic!("validation failed: {}", e));
        let validation_time = validation_start.elapsed();
        println!("  🛡️ Validate: {:?}", validation_time);
        
        // Legacy behavior: get_evaluated_schema takes skip_layout: bool
        // We pass false to ensure layout IS resolved
        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));
        let validation_path = samples_dir.join(format!("{}-validation.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));

        let validation_value = serde_json::to_value(&validation_result)
            .unwrap_or_else(|e| panic!("failed to serialize validation result: {}", e));
        fs::write(&validation_path, common::pretty_json(&validation_value))
            .unwrap_or_else(|e| panic!("failed to write {}: {}", validation_path.display(), e));

        println!("✅ Results saved:");
        println!("  - {}", evaluated_path.display());
        println!("  - {}", parsed_path.display());
        println!("  - {}", value_path.display());
        println!("  - {}\n", validation_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");
}

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.