Struct MdxFile

Source

pub struct MdxFile { /* private fields */ }

Expand description

Opened .mdx dictionary file.

Implementations§

Source §

impl MdxFile

Source

pub fn open(path: impl AsRef<Path>) -> Result<Self>

Opens an MDX file with default options.

Examples found in repository ?

examples/inspect.rs (line 17)

5fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let mut args = env::args().skip(1);
7    let mode = args
8        .next()
9        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
10    let path = args
11        .next()
12        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
13    let lookup_key = args.next();
14
15    match mode.as_str() {
16        "mdx" => {
17            let file = MdxFile::open(&path)?;
18            println!("entries={}", file.len());
19            println!("title={:?}", file.header().title);
20            println!(
21                "description_present={}",
22                file.header().description.is_some()
23            );
24            if let Some(key) = lookup_key {
25                match file.lookup(&key)? {
26                    Some(record) => {
27                        println!("key={}", record.key);
28                        println!("text_prefix={}", prefix(&record.text, 200));
29                    }
30                    None => println!("not found"),
31                }
32            } else {
33                for entry in file.entries().take(5) {
34                    let entry = entry?;
35                    println!("{} => {}", entry.key, prefix(&entry.text, 80));
36                }
37            }
38        }
39        "mdd" => {
40            let file = MddFile::open(&path)?;
41            println!("entries={}", file.len());
42            println!("title={:?}", file.header().title);
43            if let Some(key) = lookup_key {
44                match file.lookup(&key)? {
45                    Some(resource) => {
46                        println!("key={}", resource.key);
47                        println!("bytes={}", resource.data.len());
48                        println!(
49                            "prefix={:02x?}",
50                            &resource.data[..resource.data.len().min(16)]
51                        );
52                    }
53                    None => println!("not found"),
54                }
55            } else {
56                for entry in file.entries().take(5) {
57                    let entry = entry?;
58                    println!("{} => {} bytes", entry.key, entry.data.len());
59                }
60            }
61        }
62        _ => return Err("mode must be mdx or mdd".into()),
63    }
64
65    Ok(())
66}

More examples

Hide additional examples

examples/bench_local.rs (line 16)

6fn main() -> Result<(), Box<dyn std::error::Error>> {
7    let mut args = env::args().skip(1);
8    let mdx_path = args
9        .next()
10        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
11    let mdd_path = args
12        .next()
13        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
14
15    let open_start = Instant::now();
16    let mdx = MdxFile::open(&mdx_path)?;
17    let mdx_open = open_start.elapsed();
18
19    let queries = ["apple", "book", "zebra", "Apple"];
20    let lookup_start = Instant::now();
21    let mut total_chars = 0usize;
22    for query in queries {
23        let record = mdx.lookup(query)?.ok_or("missing benchmark MDX key")?;
24        total_chars += record.text.len();
25    }
26    let mdx_lookup = lookup_start.elapsed();
27
28    let key_scan_start = Instant::now();
29    let mut mdx_key_count = 0usize;
30    let mut mdx_key_bytes = 0usize;
31    for key in mdx.keys() {
32        let key = key?;
33        mdx_key_count += 1;
34        mdx_key_bytes += key.len();
35    }
36    let mdx_key_scan = key_scan_start.elapsed();
37
38    let entry_scan_start = Instant::now();
39    let mut mdx_entry_count = 0usize;
40    let mut mdx_entry_key_bytes = 0usize;
41    let mut mdx_entry_text_bytes = 0usize;
42    for entry in mdx.entries() {
43        let entry = entry?;
44        mdx_entry_count += 1;
45        mdx_entry_key_bytes += entry.key.len();
46        mdx_entry_text_bytes += entry.text.len();
47    }
48    let mdx_entry_scan = entry_scan_start.elapsed();
49
50    let open_start = Instant::now();
51    let mdd = MddFile::open(&mdd_path)?;
52    let mdd_open = open_start.elapsed();
53
54    let lookup_start = Instant::now();
55    let css = mdd
56        .lookup("\\LM5style.css")?
57        .ok_or("missing benchmark MDD key")?;
58    let mdd_lookup = lookup_start.elapsed();
59
60    let key_scan_start = Instant::now();
61    let mut mdd_key_count = 0usize;
62    let mut mdd_key_bytes = 0usize;
63    for key in mdd.keys() {
64        let key = key?;
65        mdd_key_count += 1;
66        mdd_key_bytes += key.len();
67    }
68    let mdd_key_scan = key_scan_start.elapsed();
69
70    let entry_scan_start = Instant::now();
71    let mut mdd_entry_count = 0usize;
72    let mut mdd_entry_key_bytes = 0usize;
73    let mut mdd_entry_data_bytes = 0usize;
74    for entry in mdd.entries() {
75        let entry = entry?;
76        mdd_entry_count += 1;
77        mdd_entry_key_bytes += entry.key.len();
78        mdd_entry_data_bytes += entry.data.len();
79    }
80    let mdd_entry_scan = entry_scan_start.elapsed();
81
82    println!("mdx_open_ms={}", mdx_open.as_millis());
83    println!("mdx_lookup_ms_total={}", mdx_lookup.as_millis());
84    println!(
85        "mdx_lookup_ms_avg={:.2}",
86        mdx_lookup.as_secs_f64() * 1000.0 / queries.len() as f64
87    );
88    println!("mdx_total_chars={total_chars}");
89    println!("mdx_keys_scan_ms_total={}", mdx_key_scan.as_millis());
90    println!("mdx_keys_scan_count={mdx_key_count}");
91    println!("mdx_keys_scan_total_bytes={mdx_key_bytes}");
92    println!("mdx_entries_scan_ms_total={}", mdx_entry_scan.as_millis());
93    println!("mdx_entries_scan_count={mdx_entry_count}");
94    println!("mdx_entries_scan_key_bytes={mdx_entry_key_bytes}");
95    println!("mdx_entries_scan_text_bytes={mdx_entry_text_bytes}");
96    println!("mdd_open_ms={}", mdd_open.as_millis());
97    println!("mdd_lookup_ms_total={}", mdd_lookup.as_millis());
98    println!("mdd_css_bytes={}", css.data.len());
99    println!("mdd_keys_scan_ms_total={}", mdd_key_scan.as_millis());
100    println!("mdd_keys_scan_count={mdd_key_count}");
101    println!("mdd_keys_scan_total_bytes={mdd_key_bytes}");
102    println!("mdd_entries_scan_ms_total={}", mdd_entry_scan.as_millis());
103    println!("mdd_entries_scan_count={mdd_entry_count}");
104    println!("mdd_entries_scan_key_bytes={mdd_entry_key_bytes}");
105    println!("mdd_entries_scan_data_bytes={mdd_entry_data_bytes}");
106
107    Ok(())
108}

Source

pub fn open_with_options( path: impl AsRef<Path>, options: OpenOptions, ) -> Result<Self>

Opens an MDX file with explicit options.

Returns the parsed top-level header metadata.

Examples found in repository ?

examples/inspect.rs (line 19)

5fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let mut args = env::args().skip(1);
7    let mode = args
8        .next()
9        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
10    let path = args
11        .next()
12        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
13    let lookup_key = args.next();
14
15    match mode.as_str() {
16        "mdx" => {
17            let file = MdxFile::open(&path)?;
18            println!("entries={}", file.len());
19            println!("title={:?}", file.header().title);
20            println!(
21                "description_present={}",
22                file.header().description.is_some()
23            );
24            if let Some(key) = lookup_key {
25                match file.lookup(&key)? {
26                    Some(record) => {
27                        println!("key={}", record.key);
28                        println!("text_prefix={}", prefix(&record.text, 200));
29                    }
30                    None => println!("not found"),
31                }
32            } else {
33                for entry in file.entries().take(5) {
34                    let entry = entry?;
35                    println!("{} => {}", entry.key, prefix(&entry.text, 80));
36                }
37            }
38        }
39        "mdd" => {
40            let file = MddFile::open(&path)?;
41            println!("entries={}", file.len());
42            println!("title={:?}", file.header().title);
43            if let Some(key) = lookup_key {
44                match file.lookup(&key)? {
45                    Some(resource) => {
46                        println!("key={}", resource.key);
47                        println!("bytes={}", resource.data.len());
48                        println!(
49                            "prefix={:02x?}",
50                            &resource.data[..resource.data.len().min(16)]
51                        );
52                    }
53                    None => println!("not found"),
54                }
55            } else {
56                for entry in file.entries().take(5) {
57                    let entry = entry?;
58                    println!("{} => {} bytes", entry.key, entry.data.len());
59                }
60            }
61        }
62        _ => return Err("mode must be mdx or mdd".into()),
63    }
64
65    Ok(())
66}

Source

pub fn len(&self) -> u64

Returns the number of dictionary entries declared by the file.

Examples found in repository ?

examples/inspect.rs (line 18)

5fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let mut args = env::args().skip(1);
7    let mode = args
8        .next()
9        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
10    let path = args
11        .next()
12        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
13    let lookup_key = args.next();
14
15    match mode.as_str() {
16        "mdx" => {
17            let file = MdxFile::open(&path)?;
18            println!("entries={}", file.len());
19            println!("title={:?}", file.header().title);
20            println!(
21                "description_present={}",
22                file.header().description.is_some()
23            );
24            if let Some(key) = lookup_key {
25                match file.lookup(&key)? {
26                    Some(record) => {
27                        println!("key={}", record.key);
28                        println!("text_prefix={}", prefix(&record.text, 200));
29                    }
30                    None => println!("not found"),
31                }
32            } else {
33                for entry in file.entries().take(5) {
34                    let entry = entry?;
35                    println!("{} => {}", entry.key, prefix(&entry.text, 80));
36                }
37            }
38        }
39        "mdd" => {
40            let file = MddFile::open(&path)?;
41            println!("entries={}", file.len());
42            println!("title={:?}", file.header().title);
43            if let Some(key) = lookup_key {
44                match file.lookup(&key)? {
45                    Some(resource) => {
46                        println!("key={}", resource.key);
47                        println!("bytes={}", resource.data.len());
48                        println!(
49                            "prefix={:02x?}",
50                            &resource.data[..resource.data.len().min(16)]
51                        );
52                    }
53                    None => println!("not found"),
54                }
55            } else {
56                for entry in file.entries().take(5) {
57                    let entry = entry?;
58                    println!("{} => {} bytes", entry.key, entry.data.len());
59                }
60            }
61        }
62        _ => return Err("mode must be mdx or mdd".into()),
63    }
64
65    Ok(())
66}

Source

pub fn lookup(&self, key: &str) -> Result<Option<MdxRecord>>

Performs a lazy lookup for a single MDX key.

Examples found in repository ?

examples/inspect.rs (line 25)

5fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let mut args = env::args().skip(1);
7    let mode = args
8        .next()
9        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
10    let path = args
11        .next()
12        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
13    let lookup_key = args.next();
14
15    match mode.as_str() {
16        "mdx" => {
17            let file = MdxFile::open(&path)?;
18            println!("entries={}", file.len());
19            println!("title={:?}", file.header().title);
20            println!(
21                "description_present={}",
22                file.header().description.is_some()
23            );
24            if let Some(key) = lookup_key {
25                match file.lookup(&key)? {
26                    Some(record) => {
27                        println!("key={}", record.key);
28                        println!("text_prefix={}", prefix(&record.text, 200));
29                    }
30                    None => println!("not found"),
31                }
32            } else {
33                for entry in file.entries().take(5) {
34                    let entry = entry?;
35                    println!("{} => {}", entry.key, prefix(&entry.text, 80));
36                }
37            }
38        }
39        "mdd" => {
40            let file = MddFile::open(&path)?;
41            println!("entries={}", file.len());
42            println!("title={:?}", file.header().title);
43            if let Some(key) = lookup_key {
44                match file.lookup(&key)? {
45                    Some(resource) => {
46                        println!("key={}", resource.key);
47                        println!("bytes={}", resource.data.len());
48                        println!(
49                            "prefix={:02x?}",
50                            &resource.data[..resource.data.len().min(16)]
51                        );
52                    }
53                    None => println!("not found"),
54                }
55            } else {
56                for entry in file.entries().take(5) {
57                    let entry = entry?;
58                    println!("{} => {} bytes", entry.key, entry.data.len());
59                }
60            }
61        }
62        _ => return Err("mode must be mdx or mdd".into()),
63    }
64
65    Ok(())
66}

More examples

Hide additional examples

examples/bench_local.rs (line 23)

6fn main() -> Result<(), Box<dyn std::error::Error>> {
7    let mut args = env::args().skip(1);
8    let mdx_path = args
9        .next()
10        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
11    let mdd_path = args
12        .next()
13        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
14
15    let open_start = Instant::now();
16    let mdx = MdxFile::open(&mdx_path)?;
17    let mdx_open = open_start.elapsed();
18
19    let queries = ["apple", "book", "zebra", "Apple"];
20    let lookup_start = Instant::now();
21    let mut total_chars = 0usize;
22    for query in queries {
23        let record = mdx.lookup(query)?.ok_or("missing benchmark MDX key")?;
24        total_chars += record.text.len();
25    }
26    let mdx_lookup = lookup_start.elapsed();
27
28    let key_scan_start = Instant::now();
29    let mut mdx_key_count = 0usize;
30    let mut mdx_key_bytes = 0usize;
31    for key in mdx.keys() {
32        let key = key?;
33        mdx_key_count += 1;
34        mdx_key_bytes += key.len();
35    }
36    let mdx_key_scan = key_scan_start.elapsed();
37
38    let entry_scan_start = Instant::now();
39    let mut mdx_entry_count = 0usize;
40    let mut mdx_entry_key_bytes = 0usize;
41    let mut mdx_entry_text_bytes = 0usize;
42    for entry in mdx.entries() {
43        let entry = entry?;
44        mdx_entry_count += 1;
45        mdx_entry_key_bytes += entry.key.len();
46        mdx_entry_text_bytes += entry.text.len();
47    }
48    let mdx_entry_scan = entry_scan_start.elapsed();
49
50    let open_start = Instant::now();
51    let mdd = MddFile::open(&mdd_path)?;
52    let mdd_open = open_start.elapsed();
53
54    let lookup_start = Instant::now();
55    let css = mdd
56        .lookup("\\LM5style.css")?
57        .ok_or("missing benchmark MDD key")?;
58    let mdd_lookup = lookup_start.elapsed();
59
60    let key_scan_start = Instant::now();
61    let mut mdd_key_count = 0usize;
62    let mut mdd_key_bytes = 0usize;
63    for key in mdd.keys() {
64        let key = key?;
65        mdd_key_count += 1;
66        mdd_key_bytes += key.len();
67    }
68    let mdd_key_scan = key_scan_start.elapsed();
69
70    let entry_scan_start = Instant::now();
71    let mut mdd_entry_count = 0usize;
72    let mut mdd_entry_key_bytes = 0usize;
73    let mut mdd_entry_data_bytes = 0usize;
74    for entry in mdd.entries() {
75        let entry = entry?;
76        mdd_entry_count += 1;
77        mdd_entry_key_bytes += entry.key.len();
78        mdd_entry_data_bytes += entry.data.len();
79    }
80    let mdd_entry_scan = entry_scan_start.elapsed();
81
82    println!("mdx_open_ms={}", mdx_open.as_millis());
83    println!("mdx_lookup_ms_total={}", mdx_lookup.as_millis());
84    println!(
85        "mdx_lookup_ms_avg={:.2}",
86        mdx_lookup.as_secs_f64() * 1000.0 / queries.len() as f64
87    );
88    println!("mdx_total_chars={total_chars}");
89    println!("mdx_keys_scan_ms_total={}", mdx_key_scan.as_millis());
90    println!("mdx_keys_scan_count={mdx_key_count}");
91    println!("mdx_keys_scan_total_bytes={mdx_key_bytes}");
92    println!("mdx_entries_scan_ms_total={}", mdx_entry_scan.as_millis());
93    println!("mdx_entries_scan_count={mdx_entry_count}");
94    println!("mdx_entries_scan_key_bytes={mdx_entry_key_bytes}");
95    println!("mdx_entries_scan_text_bytes={mdx_entry_text_bytes}");
96    println!("mdd_open_ms={}", mdd_open.as_millis());
97    println!("mdd_lookup_ms_total={}", mdd_lookup.as_millis());
98    println!("mdd_css_bytes={}", css.data.len());
99    println!("mdd_keys_scan_ms_total={}", mdd_key_scan.as_millis());
100    println!("mdd_keys_scan_count={mdd_key_count}");
101    println!("mdd_keys_scan_total_bytes={mdd_key_bytes}");
102    println!("mdd_entries_scan_ms_total={}", mdd_entry_scan.as_millis());
103    println!("mdd_entries_scan_count={mdd_entry_count}");
104    println!("mdd_entries_scan_key_bytes={mdd_entry_key_bytes}");
105    println!("mdd_entries_scan_data_bytes={mdd_entry_data_bytes}");
106
107    Ok(())
108}

Source

pub fn keys(&self) -> MdxKeyIter<'_> ⓘ

Returns a lazy iterator over decoded keys without reading records.

Examples found in repository ?

examples/bench_local.rs (line 31)

6fn main() -> Result<(), Box<dyn std::error::Error>> {
7    let mut args = env::args().skip(1);
8    let mdx_path = args
9        .next()
10        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
11    let mdd_path = args
12        .next()
13        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
14
15    let open_start = Instant::now();
16    let mdx = MdxFile::open(&mdx_path)?;
17    let mdx_open = open_start.elapsed();
18
19    let queries = ["apple", "book", "zebra", "Apple"];
20    let lookup_start = Instant::now();
21    let mut total_chars = 0usize;
22    for query in queries {
23        let record = mdx.lookup(query)?.ok_or("missing benchmark MDX key")?;
24        total_chars += record.text.len();
25    }
26    let mdx_lookup = lookup_start.elapsed();
27
28    let key_scan_start = Instant::now();
29    let mut mdx_key_count = 0usize;
30    let mut mdx_key_bytes = 0usize;
31    for key in mdx.keys() {
32        let key = key?;
33        mdx_key_count += 1;
34        mdx_key_bytes += key.len();
35    }
36    let mdx_key_scan = key_scan_start.elapsed();
37
38    let entry_scan_start = Instant::now();
39    let mut mdx_entry_count = 0usize;
40    let mut mdx_entry_key_bytes = 0usize;
41    let mut mdx_entry_text_bytes = 0usize;
42    for entry in mdx.entries() {
43        let entry = entry?;
44        mdx_entry_count += 1;
45        mdx_entry_key_bytes += entry.key.len();
46        mdx_entry_text_bytes += entry.text.len();
47    }
48    let mdx_entry_scan = entry_scan_start.elapsed();
49
50    let open_start = Instant::now();
51    let mdd = MddFile::open(&mdd_path)?;
52    let mdd_open = open_start.elapsed();
53
54    let lookup_start = Instant::now();
55    let css = mdd
56        .lookup("\\LM5style.css")?
57        .ok_or("missing benchmark MDD key")?;
58    let mdd_lookup = lookup_start.elapsed();
59
60    let key_scan_start = Instant::now();
61    let mut mdd_key_count = 0usize;
62    let mut mdd_key_bytes = 0usize;
63    for key in mdd.keys() {
64        let key = key?;
65        mdd_key_count += 1;
66        mdd_key_bytes += key.len();
67    }
68    let mdd_key_scan = key_scan_start.elapsed();
69
70    let entry_scan_start = Instant::now();
71    let mut mdd_entry_count = 0usize;
72    let mut mdd_entry_key_bytes = 0usize;
73    let mut mdd_entry_data_bytes = 0usize;
74    for entry in mdd.entries() {
75        let entry = entry?;
76        mdd_entry_count += 1;
77        mdd_entry_key_bytes += entry.key.len();
78        mdd_entry_data_bytes += entry.data.len();
79    }
80    let mdd_entry_scan = entry_scan_start.elapsed();
81
82    println!("mdx_open_ms={}", mdx_open.as_millis());
83    println!("mdx_lookup_ms_total={}", mdx_lookup.as_millis());
84    println!(
85        "mdx_lookup_ms_avg={:.2}",
86        mdx_lookup.as_secs_f64() * 1000.0 / queries.len() as f64
87    );
88    println!("mdx_total_chars={total_chars}");
89    println!("mdx_keys_scan_ms_total={}", mdx_key_scan.as_millis());
90    println!("mdx_keys_scan_count={mdx_key_count}");
91    println!("mdx_keys_scan_total_bytes={mdx_key_bytes}");
92    println!("mdx_entries_scan_ms_total={}", mdx_entry_scan.as_millis());
93    println!("mdx_entries_scan_count={mdx_entry_count}");
94    println!("mdx_entries_scan_key_bytes={mdx_entry_key_bytes}");
95    println!("mdx_entries_scan_text_bytes={mdx_entry_text_bytes}");
96    println!("mdd_open_ms={}", mdd_open.as_millis());
97    println!("mdd_lookup_ms_total={}", mdd_lookup.as_millis());
98    println!("mdd_css_bytes={}", css.data.len());
99    println!("mdd_keys_scan_ms_total={}", mdd_key_scan.as_millis());
100    println!("mdd_keys_scan_count={mdd_key_count}");
101    println!("mdd_keys_scan_total_bytes={mdd_key_bytes}");
102    println!("mdd_entries_scan_ms_total={}", mdd_entry_scan.as_millis());
103    println!("mdd_entries_scan_count={mdd_entry_count}");
104    println!("mdd_entries_scan_key_bytes={mdd_entry_key_bytes}");
105    println!("mdd_entries_scan_data_bytes={mdd_entry_data_bytes}");
106
107    Ok(())
108}

Source

pub fn keys_with_ordinals(&self) -> MdxOrdinalKeyIter<'_> ⓘ

Returns a lazy iterator over decoded keys with stable ordinals.

Source

pub fn key_at(&self, ordinal: KeyOrdinal) -> Result<Option<String>>

Returns the original key at a stable ordinal without reading records.

Source

pub fn keys_at(&self, ordinals: &[KeyOrdinal]) -> Result<Vec<Option<String>>>

Returns original keys for a batch of ordinals in input order.

Source

pub fn entries(&self) -> MdxEntryIter<'_> ⓘ

Examples found in repository ?

examples/inspect.rs (line 33)

5fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let mut args = env::args().skip(1);
7    let mode = args
8        .next()
9        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
10    let path = args
11        .next()
12        .ok_or("usage: inspect <mdx|mdd> <path> [lookup_key]")?;
13    let lookup_key = args.next();
14
15    match mode.as_str() {
16        "mdx" => {
17            let file = MdxFile::open(&path)?;
18            println!("entries={}", file.len());
19            println!("title={:?}", file.header().title);
20            println!(
21                "description_present={}",
22                file.header().description.is_some()
23            );
24            if let Some(key) = lookup_key {
25                match file.lookup(&key)? {
26                    Some(record) => {
27                        println!("key={}", record.key);
28                        println!("text_prefix={}", prefix(&record.text, 200));
29                    }
30                    None => println!("not found"),
31                }
32            } else {
33                for entry in file.entries().take(5) {
34                    let entry = entry?;
35                    println!("{} => {}", entry.key, prefix(&entry.text, 80));
36                }
37            }
38        }
39        "mdd" => {
40            let file = MddFile::open(&path)?;
41            println!("entries={}", file.len());
42            println!("title={:?}", file.header().title);
43            if let Some(key) = lookup_key {
44                match file.lookup(&key)? {
45                    Some(resource) => {
46                        println!("key={}", resource.key);
47                        println!("bytes={}", resource.data.len());
48                        println!(
49                            "prefix={:02x?}",
50                            &resource.data[..resource.data.len().min(16)]
51                        );
52                    }
53                    None => println!("not found"),
54                }
55            } else {
56                for entry in file.entries().take(5) {
57                    let entry = entry?;
58                    println!("{} => {} bytes", entry.key, entry.data.len());
59                }
60            }
61        }
62        _ => return Err("mode must be mdx or mdd".into()),
63    }
64
65    Ok(())
66}

More examples

Hide additional examples

examples/bench_local.rs (line 42)

6fn main() -> Result<(), Box<dyn std::error::Error>> {
7    let mut args = env::args().skip(1);
8    let mdx_path = args
9        .next()
10        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
11    let mdd_path = args
12        .next()
13        .ok_or("usage: bench_local <mdx_path> <mdd_path>")?;
14
15    let open_start = Instant::now();
16    let mdx = MdxFile::open(&mdx_path)?;
17    let mdx_open = open_start.elapsed();
18
19    let queries = ["apple", "book", "zebra", "Apple"];
20    let lookup_start = Instant::now();
21    let mut total_chars = 0usize;
22    for query in queries {
23        let record = mdx.lookup(query)?.ok_or("missing benchmark MDX key")?;
24        total_chars += record.text.len();
25    }
26    let mdx_lookup = lookup_start.elapsed();
27
28    let key_scan_start = Instant::now();
29    let mut mdx_key_count = 0usize;
30    let mut mdx_key_bytes = 0usize;
31    for key in mdx.keys() {
32        let key = key?;
33        mdx_key_count += 1;
34        mdx_key_bytes += key.len();
35    }
36    let mdx_key_scan = key_scan_start.elapsed();
37
38    let entry_scan_start = Instant::now();
39    let mut mdx_entry_count = 0usize;
40    let mut mdx_entry_key_bytes = 0usize;
41    let mut mdx_entry_text_bytes = 0usize;
42    for entry in mdx.entries() {
43        let entry = entry?;
44        mdx_entry_count += 1;
45        mdx_entry_key_bytes += entry.key.len();
46        mdx_entry_text_bytes += entry.text.len();
47    }
48    let mdx_entry_scan = entry_scan_start.elapsed();
49
50    let open_start = Instant::now();
51    let mdd = MddFile::open(&mdd_path)?;
52    let mdd_open = open_start.elapsed();
53
54    let lookup_start = Instant::now();
55    let css = mdd
56        .lookup("\\LM5style.css")?
57        .ok_or("missing benchmark MDD key")?;
58    let mdd_lookup = lookup_start.elapsed();
59
60    let key_scan_start = Instant::now();
61    let mut mdd_key_count = 0usize;
62    let mut mdd_key_bytes = 0usize;
63    for key in mdd.keys() {
64        let key = key?;
65        mdd_key_count += 1;
66        mdd_key_bytes += key.len();
67    }
68    let mdd_key_scan = key_scan_start.elapsed();
69
70    let entry_scan_start = Instant::now();
71    let mut mdd_entry_count = 0usize;
72    let mut mdd_entry_key_bytes = 0usize;
73    let mut mdd_entry_data_bytes = 0usize;
74    for entry in mdd.entries() {
75        let entry = entry?;
76        mdd_entry_count += 1;
77        mdd_entry_key_bytes += entry.key.len();
78        mdd_entry_data_bytes += entry.data.len();
79    }
80    let mdd_entry_scan = entry_scan_start.elapsed();
81
82    println!("mdx_open_ms={}", mdx_open.as_millis());
83    println!("mdx_lookup_ms_total={}", mdx_lookup.as_millis());
84    println!(
85        "mdx_lookup_ms_avg={:.2}",
86        mdx_lookup.as_secs_f64() * 1000.0 / queries.len() as f64
87    );
88    println!("mdx_total_chars={total_chars}");
89    println!("mdx_keys_scan_ms_total={}", mdx_key_scan.as_millis());
90    println!("mdx_keys_scan_count={mdx_key_count}");
91    println!("mdx_keys_scan_total_bytes={mdx_key_bytes}");
92    println!("mdx_entries_scan_ms_total={}", mdx_entry_scan.as_millis());
93    println!("mdx_entries_scan_count={mdx_entry_count}");
94    println!("mdx_entries_scan_key_bytes={mdx_entry_key_bytes}");
95    println!("mdx_entries_scan_text_bytes={mdx_entry_text_bytes}");
96    println!("mdd_open_ms={}", mdd_open.as_millis());
97    println!("mdd_lookup_ms_total={}", mdd_lookup.as_millis());
98    println!("mdd_css_bytes={}", css.data.len());
99    println!("mdd_keys_scan_ms_total={}", mdd_key_scan.as_millis());
100    println!("mdd_keys_scan_count={mdd_key_count}");
101    println!("mdd_keys_scan_total_bytes={mdd_key_bytes}");
102    println!("mdd_entries_scan_ms_total={}", mdd_entry_scan.as_millis());
103    println!("mdd_entries_scan_count={mdd_entry_count}");
104    println!("mdd_entries_scan_key_bytes={mdd_entry_key_bytes}");
105    println!("mdd_entries_scan_data_bytes={mdd_entry_data_bytes}");
106
107    Ok(())
108}