Struct DeviceManager

pub struct DeviceManager {
    pub reader: Reader,
    pub last_load_time: Option<Duration>,
    /* private fields */
}

Fields

reader: Reader

last_load_time: Option<Duration>

Implementations

impl DeviceManager

pub fn new(filename: &str) -> Result<Self, Error>

pub fn new_with_cache_size( filename: &str, max_cache_size: usize, ) -> Result<Self, Error>

pub fn match_device(&self, user_agent: &str) -> Device<'_>

Examples found in repository

examples/simple_match.rs (line 30)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().collect();

    let db_file = args
        .get(1)
        .map(|s| s.as_str())
        .unwrap_or("/Users/zhaopeng/project/devcache/51Degrees-EnterpriseV3.4.trie");

    let default_ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0";
    let user_agent = args.get(2).map(|s| s.as_str()).unwrap_or(default_ua);

    println!("开始加载设备数据库文件...");
    let total_start = Instant::now();

    // 创建DeviceManager实例
    match create_device_manager(db_file) {
        Ok(manager) => {
            // 获取加载时间
            if let Some(duration) = manager.get_load_time() {
                println!("数据库加载完成，耗时: {:?}", duration);
            }

            // 首次解析（未缓存）
            println!("\n首次解析User-Agent (未缓存)...");
            let first_parse_start = Instant::now();
            let device = manager.match_device(user_agent);
            let first_parse_time = first_parse_start.elapsed();
            println!("首次解析完成，耗时: {:?}", first_parse_time);

            println!("\n基本匹配结果:");
            print_device_info(&device);

            // 再次解析相同的UA（使用缓存）
            println!("\n再次解析相同User-Agent (使用缓存)...");
            let second_parse_start = Instant::now();
            let _device = manager.match_device(user_agent);
            let second_parse_time = second_parse_start.elapsed();
            println!("二次解析完成，耗时: {:?}", second_parse_time);

            // 计算性能提升
            if first_parse_time > second_parse_time {
                let speedup =
                    first_parse_time.as_nanos() as f64 / second_parse_time.as_nanos() as f64;
                println!("\n缓存性能提升: {:.2}倍", speedup);
            }

            // 打印缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);
            println!("  当前缓存大小: {}", manager.get_cache_size());

            // 批量测试
            println!("\n执行10次相同查询的批量测试...");
            let batch_start = Instant::now();

            for i in 1..=10 {
                let start = Instant::now();
                let _device = manager.match_device(user_agent);
                println!("  查询 #{}: {:?}", i, start.elapsed());
            }

            println!("10次查询总耗时: {:?}", batch_start.elapsed());

            // 再次查看缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n更新后的缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);

            // 总计耗时
            println!("\n总计耗时: {:?}", total_start.elapsed());
        }
        Err(e) => println!("创建设备管理器出错: {}", e),
    }

    Ok(())
}

pub fn get_cached_property( &self, user_agent: &str, property_name: &str, ) -> Option<String>

pub fn get_load_time(&self) -> Option<Duration>

Examples found in repository

examples/simple_match.rs (line 23)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().collect();

    let db_file = args
        .get(1)
        .map(|s| s.as_str())
        .unwrap_or("/Users/zhaopeng/project/devcache/51Degrees-EnterpriseV3.4.trie");

    let default_ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0";
    let user_agent = args.get(2).map(|s| s.as_str()).unwrap_or(default_ua);

    println!("开始加载设备数据库文件...");
    let total_start = Instant::now();

    // 创建DeviceManager实例
    match create_device_manager(db_file) {
        Ok(manager) => {
            // 获取加载时间
            if let Some(duration) = manager.get_load_time() {
                println!("数据库加载完成，耗时: {:?}", duration);
            }

            // 首次解析（未缓存）
            println!("\n首次解析User-Agent (未缓存)...");
            let first_parse_start = Instant::now();
            let device = manager.match_device(user_agent);
            let first_parse_time = first_parse_start.elapsed();
            println!("首次解析完成，耗时: {:?}", first_parse_time);

            println!("\n基本匹配结果:");
            print_device_info(&device);

            // 再次解析相同的UA（使用缓存）
            println!("\n再次解析相同User-Agent (使用缓存)...");
            let second_parse_start = Instant::now();
            let _device = manager.match_device(user_agent);
            let second_parse_time = second_parse_start.elapsed();
            println!("二次解析完成，耗时: {:?}", second_parse_time);

            // 计算性能提升
            if first_parse_time > second_parse_time {
                let speedup =
                    first_parse_time.as_nanos() as f64 / second_parse_time.as_nanos() as f64;
                println!("\n缓存性能提升: {:.2}倍", speedup);
            }

            // 打印缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);
            println!("  当前缓存大小: {}", manager.get_cache_size());

            // 批量测试
            println!("\n执行10次相同查询的批量测试...");
            let batch_start = Instant::now();

            for i in 1..=10 {
                let start = Instant::now();
                let _device = manager.match_device(user_agent);
                println!("  查询 #{}: {:?}", i, start.elapsed());
            }

            println!("10次查询总耗时: {:?}", batch_start.elapsed());

            // 再次查看缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n更新后的缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);

            // 总计耗时
            println!("\n总计耗时: {:?}", total_start.elapsed());
        }
        Err(e) => println!("创建设备管理器出错: {}", e),
    }

    Ok(())
}

pub fn get_parse_time(&self) -> Option<Duration>

pub fn get_cache_stats(&self) -> (usize, usize, f64)

Examples found in repository

examples/simple_match.rs (line 52)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().collect();

    let db_file = args
        .get(1)
        .map(|s| s.as_str())
        .unwrap_or("/Users/zhaopeng/project/devcache/51Degrees-EnterpriseV3.4.trie");

    let default_ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0";
    let user_agent = args.get(2).map(|s| s.as_str()).unwrap_or(default_ua);

    println!("开始加载设备数据库文件...");
    let total_start = Instant::now();

    // 创建DeviceManager实例
    match create_device_manager(db_file) {
        Ok(manager) => {
            // 获取加载时间
            if let Some(duration) = manager.get_load_time() {
                println!("数据库加载完成，耗时: {:?}", duration);
            }

            // 首次解析（未缓存）
            println!("\n首次解析User-Agent (未缓存)...");
            let first_parse_start = Instant::now();
            let device = manager.match_device(user_agent);
            let first_parse_time = first_parse_start.elapsed();
            println!("首次解析完成，耗时: {:?}", first_parse_time);

            println!("\n基本匹配结果:");
            print_device_info(&device);

            // 再次解析相同的UA（使用缓存）
            println!("\n再次解析相同User-Agent (使用缓存)...");
            let second_parse_start = Instant::now();
            let _device = manager.match_device(user_agent);
            let second_parse_time = second_parse_start.elapsed();
            println!("二次解析完成，耗时: {:?}", second_parse_time);

            // 计算性能提升
            if first_parse_time > second_parse_time {
                let speedup =
                    first_parse_time.as_nanos() as f64 / second_parse_time.as_nanos() as f64;
                println!("\n缓存性能提升: {:.2}倍", speedup);
            }

            // 打印缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);
            println!("  当前缓存大小: {}", manager.get_cache_size());

            // 批量测试
            println!("\n执行10次相同查询的批量测试...");
            let batch_start = Instant::now();

            for i in 1..=10 {
                let start = Instant::now();
                let _device = manager.match_device(user_agent);
                println!("  查询 #{}: {:?}", i, start.elapsed());
            }

            println!("10次查询总耗时: {:?}", batch_start.elapsed());

            // 再次查看缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n更新后的缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);

            // 总计耗时
            println!("\n总计耗时: {:?}", total_start.elapsed());
        }
        Err(e) => println!("创建设备管理器出错: {}", e),
    }

    Ok(())
}

pub fn clear_cache(&self)

pub fn get_cache_size(&self) -> usize

Examples found in repository

examples/simple_match.rs (line 57)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().collect();

    let db_file = args
        .get(1)
        .map(|s| s.as_str())
        .unwrap_or("/Users/zhaopeng/project/devcache/51Degrees-EnterpriseV3.4.trie");

    let default_ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0";
    let user_agent = args.get(2).map(|s| s.as_str()).unwrap_or(default_ua);

    println!("开始加载设备数据库文件...");
    let total_start = Instant::now();

    // 创建DeviceManager实例
    match create_device_manager(db_file) {
        Ok(manager) => {
            // 获取加载时间
            if let Some(duration) = manager.get_load_time() {
                println!("数据库加载完成，耗时: {:?}", duration);
            }

            // 首次解析（未缓存）
            println!("\n首次解析User-Agent (未缓存)...");
            let first_parse_start = Instant::now();
            let device = manager.match_device(user_agent);
            let first_parse_time = first_parse_start.elapsed();
            println!("首次解析完成，耗时: {:?}", first_parse_time);

            println!("\n基本匹配结果:");
            print_device_info(&device);

            // 再次解析相同的UA（使用缓存）
            println!("\n再次解析相同User-Agent (使用缓存)...");
            let second_parse_start = Instant::now();
            let _device = manager.match_device(user_agent);
            let second_parse_time = second_parse_start.elapsed();
            println!("二次解析完成，耗时: {:?}", second_parse_time);

            // 计算性能提升
            if first_parse_time > second_parse_time {
                let speedup =
                    first_parse_time.as_nanos() as f64 / second_parse_time.as_nanos() as f64;
                println!("\n缓存性能提升: {:.2}倍", speedup);
            }

            // 打印缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);
            println!("  当前缓存大小: {}", manager.get_cache_size());

            // 批量测试
            println!("\n执行10次相同查询的批量测试...");
            let batch_start = Instant::now();

            for i in 1..=10 {
                let start = Instant::now();
                let _device = manager.match_device(user_agent);
                println!("  查询 #{}: {:?}", i, start.elapsed());
            }

            println!("10次查询总耗时: {:?}", batch_start.elapsed());

            // 再次查看缓存统计
            let (hits, misses, hit_rate) = manager.get_cache_stats();
            println!("\n更新后的缓存统计:");
            println!("  命中次数: {}", hits);
            println!("  未命中次数: {}", misses);
            println!("  命中率: {:.2}%", hit_rate);

            // 总计耗时
            println!("\n总计耗时: {:?}", total_start.elapsed());
        }
        Err(e) => println!("创建设备管理器出错: {}", e),
    }

    Ok(())
}