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


use argh::FromArgValue;

/// one of the tables that can be displayed
#[derive(Debug, Clone, Copy)]
pub enum Table {
    Dates,
    Status,
    RemoteAddresses,
    Referers,
    Paths,
    Methods,
}

pub static DEFAULT_TABLES: &[Table] = &[
    Table::Dates,
    Table::Status,
    Table::RemoteAddresses,
    Table::Referers,
    Table::Paths,
];

pub static ALL_TABLES: &[Table] = &[
    Table::Dates,
    Table::Methods,
    Table::Status,
    Table::RemoteAddresses,
    Table::Referers,
    Table::Paths,
];

#[derive(Debug, Clone)]
pub struct Tables(Vec<Table>);

impl Default for Tables {
    fn default() -> Self {
        Self (DEFAULT_TABLES.to_vec())
    }
}

impl Tables {
    fn all() -> Self {
        Self (ALL_TABLES.to_vec())
    }
}

impl IntoIterator for Tables {
    type Item = Table;
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

impl FromArgValue for Tables {
    fn from_arg_value(value: &str) -> Result<Self, String> {
        let value = value.to_lowercase();
        if value == "all" || value == "a" {
            return Ok(Self::all());
        }
        let mut v = Vec::new();
        for s in value.split(',') {
            if s.contains("date") {
                v.push(Table::Dates);
            } else if s.contains("stat") {
                v.push(Table::Status);
            } else if s.contains("addr") {
                v.push(Table::RemoteAddresses);
            } else if s.contains("ref") {
                v.push(Table::Referers);
            } else if s.contains("path") {
                v.push(Table::Paths);
            } else if s.contains("method") {
                v.push(Table::Methods);
            } else {
                return Err(format!("Unrecognized table : {:?}", s));
            }
        }
        Ok(Self(v))
    }
}