qem 0.6.2

High-performance cross-platform text engine for massive files.
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use qem::{Document, LiteralSearchQuery, TextPosition, TextSelection, ViewportRequest};
use std::env;
use std::path::PathBuf;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args_os().skip(1);
    let input = args
        .next()
        .map(PathBuf::from)
        .ok_or("usage: cargo run --example typed_editing -- <input> [output]")?;
    let output = args.next().map(PathBuf::from);

    let mut doc = Document::open(&input)?;
    print_viewport(&doc, "before edits");

    let title_selection = doc.clamp_selection(TextSelection::new(
        TextPosition::new(0, 0),
        TextPosition::new(0, 12),
    ));
    let selected = doc.read_selection(title_selection);
    println!(
        "selection: {:?}..{:?}, exact={}, text={:?}",
        title_selection.anchor(),
        title_selection.head(),
        selected.is_exact(),
        selected.text()
    );

    let cursor = doc.try_replace_selection(title_selection, "[qem-demo] ")?;
    println!("replace cursor: {:?}", cursor);

    let cut_selection = doc.clamp_selection(TextSelection::new(
        TextPosition::new(2, 0),
        TextPosition::new(2, 8),
    ));
    let cut = doc.try_cut_selection(cut_selection)?;
    println!(
        "cut text: {:?}, changed={}, cursor={:?}",
        cut.text(),
        cut.edit().changed(),
        cut.edit().cursor()
    );

    let sample =
        doc.read_text(doc.text_range_between(TextPosition::new(0, 0), TextPosition::new(2, 32)));
    println!("sample after edits: {:?}", sample.text());

    let query = LiteralSearchQuery::new("qem").ok_or("empty literal query")?;
    if let Some(found) = doc.find_next_query(&query, TextPosition::new(0, 0)) {
        println!(
            "found literal match: {:?}..{:?} -> {:?}",
            found.start(),
            found.end(),
            doc.read_text(found.range()).text()
        );

        if let Some(previous) = doc.find_prev_query(&query, found.end()) {
            println!(
                "previous literal match at-or-before {:?}: {:?}..{:?}",
                found.end(),
                previous.start(),
                previous.end()
            );
        }
    }

    print_viewport(&doc, "after edits");
    let maintenance = doc.maintenance_status();
    if let Some(stats) = maintenance.fragmentation_stats() {
        println!(
            "fragmentation: pieces={}, avg_bytes={:.1}, small_ratio={:.3}",
            stats.piece_count(),
            stats.average_piece_bytes(),
            stats.fragmentation_ratio()
        );
    }
    println!(
        "maintenance action: {}",
        maintenance.recommended_action().as_str()
    );
    if let Some(recommendation) = maintenance.compaction_recommendation() {
        println!("compaction recommended: {:?}", recommendation.urgency());
    }
    let idle_outcome = doc.run_idle_compaction()?;
    if idle_outcome.is_compacted() {
        println!("idle maintenance compacted the piece table");
    } else if idle_outcome.is_forced_pending() {
        println!("idle maintenance left a forced compaction pending for save/operator action");
    }

    if let Some(output) = output {
        doc.save_to(&output)?;
        println!("saved copy: {}", output.display());
    }

    Ok(())
}

fn print_viewport(doc: &Document, label: &str) {
    println!("{label}:");
    let viewport = doc.read_viewport(ViewportRequest::new(0, 5).with_columns(0, 120));
    for row in viewport.rows() {
        println!(
            "{:>8}: [{}] {}",
            row.line_number(),
            if row.is_exact() { "=" } else { "~" },
            row.text()
        );
    }
}