rsmarisa 0.4.0

Pure Rust port of marisa-trie: a static and space-efficient trie data structure
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Save and load example.
//!
//! This example demonstrates how to save a trie to a file and load it back,
//! showing the binary serialization capabilities of rust-marisa.

use rsmarisa::{Agent, Keyset, Trie};
use std::fs;

fn main() {
    println!("=== rust-marisa - Save/Load Example ===\n");

    // Build a trie with dictionary words (using same prefix for now)
    let mut keyset = Keyset::new();
    let words = vec!["app", "apple", "application", "apply", "append"];

    println!("Adding {} words to keyset...", words.len());
    for word in &words {
        keyset.push_back_str(word).unwrap();
    }

    let mut trie = Trie::new();
    trie.build(&mut keyset, 0);

    println!("Trie built:");
    println!("  Keys: {}", trie.num_keys());
    println!("  Nodes: {}", trie.num_nodes());
    println!("  I/O size: {} bytes\n", trie.io_size());

    // Save to file
    let filename = "example_trie.marisa";
    println!("Saving trie to '{}'...", filename);
    trie.save(filename).expect("Failed to save trie");

    // Check file size
    let metadata = fs::metadata(filename).expect("Failed to get file metadata");
    println!("File saved: {} bytes\n", metadata.len());

    // Load from file
    println!("Loading trie from '{}'...", filename);
    let mut loaded_trie = Trie::new();
    loaded_trie.load(filename).expect("Failed to load trie");

    println!("Trie loaded:");
    println!("  Keys: {}", loaded_trie.num_keys());
    println!("  Nodes: {}", loaded_trie.num_nodes());
    println!("  I/O size: {} bytes\n", loaded_trie.io_size());

    // Verify all words can be found in loaded trie
    println!("Verifying all words can be found...");
    let mut agent = Agent::new();
    agent.init_state().unwrap();

    let mut found_count = 0;
    for word in &words {
        agent.set_query_str(word);
        if loaded_trie.lookup(&mut agent) {
            found_count += 1;
        } else {
            println!("  ERROR: Could not find '{}'", word);
        }
    }

    println!("Successfully found {}/{} words", found_count, words.len());

    if found_count == words.len() {
        println!("\n✓ All words verified successfully!");
    } else {
        println!("\n✗ Some words were not found");
    }

    // Clean up
    println!("\nCleaning up...");
    fs::remove_file(filename).expect("Failed to remove file");
    println!("File '{}' removed", filename);

    println!("\n=== Example Complete ===");
}