proc_getter 0.0.3

make retriving infomations from /proc/* easier
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 crate::{Error, Result};
use std::str::FromStr;

#[derive(Debug)]
pub struct Dev {
    name: String,
    receive: [usize; 8],
    transmit: [usize; 8],
}

impl Dev {
    getter_gen! {
        name: String,
        receive: [usize;8],
        transmit: [usize; 8]
    }

    pub fn bytes_rev(&self) -> usize {
        self.receive[0]
    }

    pub fn packets_rev(&self) -> usize {
        self.receive[1]
    }

    pub fn errs_rev(&self) -> usize {
        self.receive[2]
    }

    pub fn drops_rev(&self) -> usize {
        self.receive[3]
    }

    pub fn fifo_rev(&self) -> usize {
        self.receive[4]
    }

    pub fn frame(&self) -> usize {
        self.receive[5]
    }

    pub fn compressed_rev(&self) -> usize {
        self.receive[6]
    }

    pub fn multicast(&self) -> usize {
        self.receive[7]
    }

    pub fn bytes_trs(&self) -> usize {
        self.transmit[0]
    }

    pub fn packets_trs(&self) -> usize {
        self.transmit[1]
    }

    pub fn errs_trs(&self) -> usize {
        self.transmit[2]
    }

    pub fn drop_trs(&self) -> usize {
        self.transmit[3]
    }

    pub fn fifo_trs(&self) -> usize {
        self.transmit[4]
    }

    pub fn colls(&self) -> usize {
        self.transmit[5]
    }

    pub fn carrier(&self) -> usize {
        self.transmit[6]
    }

    pub fn compressed_trs(&self) -> usize {
        self.transmit[7]
    }
}

impl FromStr for Dev {
    type Err = Error;

    fn from_str(line: &str) -> Result<Self> {
        let columns: Vec<&str> = line.split_ascii_whitespace().collect();
        if columns.len() != 17 {
            return Err(Error::BadFormat);
        }

        let name = columns[0].trim_end_matches(':').to_string();

        let mut receive = [0; 8];
        for (rev, item) in receive.iter_mut().zip(columns[1..9].iter()) {
            *rev = item.parse::<usize>()?;
        }

        let mut transmit = [0; 8];
        for (trs, item) in transmit.iter_mut().zip(columns[1..9].iter()) {
            *trs = item.parse::<usize>()?;
        }

        Ok(Dev {
            name,
            receive,
            transmit,
        })
    }
}

#[inline(always)]
fn to_dev(line: &str) -> Result<Dev> {
    Dev::from_str(line)
}

default_list! {
    dev, "/proc/net/dev", Dev, to_dev, '\n', 2
}