dnsi 0.2.0

A tool for investigating the DNS.
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

use std::io;

use super::ansi::{ITALIC, RESET, UNDERLINE};

pub struct TableWriter<'a, const N: usize> {
    pub indent: &'a str,
    pub spacing: &'a str,
    pub header: Option<[&'a str; N]>,
    pub rows: &'a [[String; N]],
    pub enabled_columns: [bool; N],
    pub right_aligned: [bool; N],
}

impl<const N: usize> Default for TableWriter<'_, N> {
    fn default() -> Self {
        Self {
            indent: "",
            spacing: "  ",
            header: None,
            rows: &[],
            enabled_columns: [true; N],
            right_aligned: [false; N],
        }
    }
}

impl<const N: usize> TableWriter<'_, N> {
    pub fn write(&self, mut target: impl io::Write) -> io::Result<()> {
        let Self {
            indent,
            spacing,
            header,
            rows,
            enabled_columns,
            right_aligned,
        } = self;

        let mut widths = [0; N];

        if let Some(header) = header {
            for i in 0..N {
                widths[i] = header[i].len();
            }
        }

        for row in *rows {
            for i in 0..N {
                widths[i] = widths[i].max(row[i].len());
            }
        }

        let columns: Vec<_> =
            (0..N).filter(|i| enabled_columns[*i]).collect();

        if columns.is_empty() {
            return Ok(());
        }

        if let Some(header) = self.header {
            write!(target, "{indent}{UNDERLINE}{ITALIC}")?;
            for &i in &columns[..columns.len() - 1] {
                write!(
                    target,
                    "{:<width$}{spacing}",
                    header[i],
                    width = widths[i]
                )?;
            }
            let last = columns[columns.len() - 1];
            write!(target, "{:<width$}", header[last], width = widths[last])?;
            writeln!(target, "{RESET}")?;
        }

        for row in *rows {
            write!(target, "{indent}")?;
            for &i in &columns[..columns.len() - 1] {
                if right_aligned[i] {
                    write!(target, "{:>width$}", row[i], width = widths[i])?;
                } else {
                    write!(target, "{:<width$}", row[i], width = widths[i])?;
                }
                write!(target, "{spacing}")?;
            }
            let last = columns[columns.len() - 1];
            if right_aligned[last] {
                write!(
                    target,
                    "{:>width$}",
                    row[last],
                    width = widths[last]
                )?;
            } else {
                write!(
                    target,
                    "{:<width$}",
                    row[last],
                    width = widths[last]
                )?;
            }
            writeln!(target)?;
        }

        Ok(())
    }
}