Struct CacheStats 

pub struct CacheStats {
    pub hits: u64,
    pub misses: u64,
    pub evictions: u64,
    pub invalidations: u64,
}

Cache statistics for monitoring and debugging.

Fields

hits: u64

Total cache hits

misses: u64

Total cache misses

evictions: u64

Total evictions due to size limit

invalidations: u64

Total invalidations due to file changes

Implementations

impl CacheStats

pub fn hit_ratio(&self) -> f64

Calculate cache hit ratio.

Examples found in repository

examples/caching_performance.rs (line 167)

fn demonstrate_loader_caching() -> Result<(), Box<dyn std::error::Error>> {
    println!("4. Advanced Loader with Caching:");
    
    // Configure loader with caching enabled
    let loader_config = LoaderConfig {
        enable_caching: true,
        cache_config: CacheConfig {
            max_size: 100,
            max_age: Some(Duration::from_secs(600)), // 10 minutes
            track_file_changes: true,
            enable_stats: true,
        },
        ..LoaderConfig::default()
    };
    
    let mut loader = TemplateLoader::with_config(loader_config);
    
    // Load templates with caching
    println!("   - Loading templates from directory (with caching)...");
    let start = Instant::now();
    let templates = loader.load_from_directory("templates")?;
    let first_load_time = start.elapsed();
    
    println!("   - First load: {} templates in {:?}", templates.len(), first_load_time);
    println!("   - Cache size: {}", loader.cache_size());
    
    // Load again to test cache performance  
    let start = Instant::now();
    let _templates = loader.load_from_directory("templates")?;
    let cached_load_time = start.elapsed();
    
    println!("   - Cached load: {:?} ({}x faster)", 
             cached_load_time,
             first_load_time.as_nanos() / cached_load_time.as_nanos().max(1));
    
    // Show cache statistics
    if let Some(stats) = loader.cache_stats() {
        println!("   - Cache hit ratio: {:.2}%", stats.hit_ratio() * 100.0);
        println!("   - Total hits: {}, misses: {}", stats.hits, stats.misses);
    }
    
    println!();
    Ok(())
}

fn demonstrate_cache_monitoring() -> Result<(), Box<dyn std::error::Error>> {
    println!("5. Cache Statistics and Monitoring:");
    
    let cache = TemplateCache::with_config(CacheConfig {
        enable_stats: true,
        max_size: 10,
        ..CacheConfig::default()
    });
    
    // Generate some cache activity
    let templates = vec![
        "Template A: @[content]@",
        "Template B: @[data]@",
        "Template C: @[info]@",
        "Template D: @[value]@",
        "Template E: @[result]@",
    ];
    
    // Insert templates
    for template_content in &templates {
        let template = TronTemplate::new(template_content)?;
        cache.insert_template(template)?;
    }
    
    // Create cache hits and misses
    for _ in 0..10 {
        // Cache hits
        let _hit = cache.get_by_content(templates[0]);
        let _hit = cache.get_by_content(templates[1]);
        
        // Cache misses
        let _miss = cache.get_by_content("Nonexistent template @[x]@");
    }
    
    // Add more templates to trigger eviction
    for i in 6..15 {
        let template = TronTemplate::new(&format!("Template {}: @[data]@", i))?;
        cache.insert_template(template)?;
    }
    
    // Display comprehensive statistics
    if let Some(stats) = cache.stats() {
        println!("   - Cache Performance Metrics:");
        println!("     * Total requests: {}", stats.hits + stats.misses);
        println!("     * Cache hits: {}", stats.hits);
        println!("     * Cache misses: {}", stats.misses);
        println!("     * Hit ratio: {:.2}%", stats.hit_ratio() * 100.0);
        println!("     * Evictions: {}", stats.evictions);
        println!("     * Invalidations: {}", stats.invalidations);
    }
    
    println!("   - Current cache size: {}", cache.size());
    println!("   - Cache is empty: {}", cache.is_empty());
    
    // Clean up expired entries
    cache.cleanup_expired();
    println!("   - After cleanup: {} templates", cache.size());
    
    println!();
    Ok(())
}

pub fn reset(&mut self)

Reset all statistics to zero.

Trait Implementations

impl Clone for CacheStats

fn clone(&self) -> CacheStats

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheStats

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

Formats the value using the given formatter.

impl Default for CacheStats

fn default() -> CacheStats

Returns the “default value” for a type.