hex_table 0.1.4

Format a byte slice into a hex table.
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

use std::io;

pub struct HexTable {
    columns: usize,
    offset: usize,
    header: bool,
    ascii: bool,
    zeros: bool,
}

impl Default for HexTable {
    fn default() -> Self {
        HexTable { columns: 16, offset: 0, header: false, ascii: true, zeros: true }
    }
}

impl HexTable {
    pub fn new(columns: usize, offset: usize, header: bool, ascii: bool, zeros: bool) -> HexTable {
        HexTable { columns, offset, header, ascii, zeros }
    }

    pub fn format<Writer: io::Write>(&self, data: &[u8], out: &mut Writer) -> io::Result<()> {
        let mut col_pos = 0;
        let mut row_pos = 0;
        let mut ascii_pos = 0;

        let data_len = data.len();
        let col_pad_len = Self::count_hex_digits(self.columns).max(2);
        let columns_remaining = data_len % self.columns;

        let columns_empty = if columns_remaining != 0 {
            self.columns - columns_remaining
        } else {
            0
        };

        let offset_str_len = Self::count_hex_digits(
            if columns_remaining != 0 {
                self.offset + data.len() - columns_remaining
            } else {
                self.offset + data.len() - columns_remaining - 1
            }
        );

        let last_row_pad_len = columns_empty * (col_pad_len + 1);
        let table_len_needed = data_len + columns_empty;

        if self.header {
            let offset = " ".repeat(offset_str_len + 2);
            let line = "-".repeat((self.columns * (col_pad_len + 1)) - 1);

            write!(out, "{}", offset)?;

            for i in 0..self.columns {
                write!(out, "{:0>1$X} ", i, col_pad_len)?;
            }

            write!(out, "\n{}{}\n", offset, line)?;
        }

        for _ in 0..(table_len_needed / self.columns) {
            write!(out, "{:0>1$X}: ", self.offset + row_pos, offset_str_len)?;

            for _ in 0..self.columns {
                if !self.zeros && data[col_pos] == 0 {
                    write!(out, "{} ", ".".repeat(col_pad_len))?;
                } else {
                    write!(out, "{:0>1$X} ", data[col_pos], col_pad_len)?;
                }

                col_pos += 1;

                if col_pos >= data_len {
                    break
                }
            }

            if self.ascii {
                if col_pos >= data_len {
                    write!(out, "{}", " ".repeat(last_row_pad_len))?;
                }

                write!(out, "| ")?;

                for _ in 0..self.columns {
                    if data[ascii_pos].is_ascii_alphanumeric() {
                        write!(out, "{}", data[ascii_pos] as char)?;
                    } else {
                        write!(out, ".")?;
                    }

                    ascii_pos += 1;

                    if ascii_pos >= data_len {
                        break
                    }
                }
            }

            row_pos += self.columns;

            if row_pos >= data_len {
                break
            }

            write!(out, "\n")?;
        }

        write!(out, "\n")?;

        Ok(())
    }

    // This was fun. It counts the number of hex digits with log16(x) + 1 for whole numbers. It uses
    // the algorithm log2(x) = size_of(x) - 1 - clz(x) then a base conversion log2(x) / log2(16).
    fn count_hex_digits(x: usize) -> usize {
        (8 * std::mem::size_of::<usize>() - 1 - x.leading_zeros() as usize) / (7 - 16u8.leading_zeros() as usize) + 1
    }
}