blart 0.5.0

An implementation of an adaptive radix tree packaged as a BTreeMap replacement
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::{
    error::Error,
    ffi::CString,
    fmt::Display,
    fs::OpenOptions,
    io::{self, BufRead, BufReader, BufWriter, Write},
    path::{Path, PathBuf},
};

use argh::FromArgs;
use blart::{
    visitor::{DotPrinter, DotPrinterSettings},
    AsBytes, NoPrefixesBytes, TreeMap,
};

#[derive(FromArgs)]
/// TREES
struct TreeToDotArgs {
    /// optional delimiter to split key from value on each file line
    #[argh(option)]
    delimiter: Option<char>,

    /// input to read keys from an external file
    #[argh(positional)]
    input_file: PathBuf,

    /// where to output the tree diagram
    ///
    /// To output to stdout, use '_'.
    #[argh(positional)]
    output_location: String,
}

fn main() {
    let args: TreeToDotArgs = argh::from_env();

    let mut tree = TreeMap::new();

    for (key, value) in read_key_values_from_text_file(&args.input_file, args.delimiter) {
        let _ = tree.insert(key, value);
    }

    if tree.is_empty() {
        panic!("Tree should now be empty after reading keys from file");
    };

    if args.output_location == "_" {
        let stdout = io::stdout();
        let handle = stdout.lock();

        let mut buffer = BufWriter::new(handle);

        write_tree(&mut buffer, tree)
    } else {
        let file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .open(args.output_location)
            .expect("Failed to open file for output");

        let mut buffer = BufWriter::new(file);

        write_tree(&mut buffer, tree)
    }
    .expect("Failed to write tree to output")
}

pub struct DisplayWrapper(CString);

impl Display for DisplayWrapper {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0.to_string_lossy())
    }
}

impl AsBytes for DisplayWrapper {
    fn as_bytes(&self) -> &[u8] {
        <CString as AsBytes>::as_bytes(&self.0)
    }
}

// SAFETY: We can impl `NoPrefixesBytes` since `CString` also implements that
unsafe impl NoPrefixesBytes for DisplayWrapper where CString: NoPrefixesBytes {}

fn write_tree(
    output: &mut dyn Write,
    tree: TreeMap<DisplayWrapper, String>,
) -> Result<(), Box<dyn Error>> {
    DotPrinter::print(output, &tree, DotPrinterSettings::default()).unwrap()?;

    Ok(())
}

fn read_key_values_from_text_file(
    text_file_path: &Path,
    delimiter: Option<char>,
) -> impl Iterator<Item = (DisplayWrapper, String)> {
    let text_file = OpenOptions::new()
        .read(true)
        .open(text_file_path)
        .expect("unable to open text file");

    BufReader::new(text_file).lines().map(move |line| {
        let line = line.expect("unable to read line");
        if let Some(delimiter) = delimiter {
            let entry_components = line.split(delimiter).collect::<Vec<_>>();

            assert_eq!(
                entry_components.len(),
                2,
                "Each line must only have delimiter once"
            );

            let key = entry_components[0];
            let value = entry_components[1];

            (
                DisplayWrapper(CString::new(String::from(key).into_bytes()).unwrap()),
                value.into(),
            )
        } else {
            (
                DisplayWrapper(CString::new(line.into_bytes()).unwrap()),
                String::new(),
            )
        }
    })
}