rustop-rs 0.4.6

Linux system information parser
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

pub fn conv_p(total: u64, free: u64) -> u64 {
    match total {
        0 => 0,
        _ => free * 100 / total,
    }
}

pub fn conv_b(bytes: u64) -> String {
    let n: f64 = bytes as f64;
    if n < 1024. {
        format!("{} B", n)
    } else if 1024. <= n && n < u64::pow(1024, 2) as f64 {
        let s = n / 1024.;
        format!("{:.2} KB", s)
    } else if u64::pow(1024, 2) as f64 <= n && n < u64::pow(1024, 3) as f64 {
        let s = n / u64::pow(1024, 2) as f64;
        format!("{:.2} MB", s)
    } else if u64::pow(1024, 3) as f64 <= n && n < u64::pow(1024, 4) as f64 {
        let s = n / u64::pow(1024, 3) as f64;
        format!("{:.2} GB", s)
    } else {
        let s = n / u64::pow(1024, 4) as f64;
        format!("{:.2} TB", s)
    }
}

#[allow(dead_code)]
pub fn conv_t(sec: f64) -> String {
    if sec < 60. {
        format!("{} seconds", sec)
    } else if 60. <= sec && sec < u64::pow(60, 2) as f64 {
        let minutes = (sec / 60.).floor();
        let seconds = (sec % 60.).floor();
        format!("{} minutes {} seconds", minutes, seconds)
    } else if u64::pow(60, 2) as f64 <= sec && sec < u64::pow(60, 3) as f64 {
        let hours = (sec / u64::pow(60, 2) as f64).floor();
        let minutes = ((sec % u64::pow(60, 2) as f64) / 60.).floor();
        let seconds = ((sec % u64::pow(60, 2) as f64) % 60.).floor();
        format!("{} hours {} minutes {} seconds", hours, minutes, seconds)
    } else {
        let days = (sec / (u64::pow(60, 2) as f64 * 24.)).floor();
        let hours = ((sec % (u64::pow(60, 2) as f64 * 24.)) / u64::pow(60, 2) as f64).floor();
        let minutes =
            (((sec % (u64::pow(60, 2) as f64 * 24.)) % u64::pow(60, 2) as f64) / 60.).floor();
        let seconds =
            (((sec % (u64::pow(60, 2) as f64 * 24.)) % u64::pow(60, 2) as f64) % 60.).floor();
        format!(
            "{} days {} hours {} minutes {} seconds",
            days, hours, minutes, seconds
        )
    }
}

pub fn conv_hex_to_ip(hex_addr: &str) -> Result<String, std::num::ParseIntError> {
    if hex_addr.len() == 8 {
        let first_oct = u8::from_str_radix(&hex_addr[6..8], 16)?;
        let second_oct = u8::from_str_radix(&hex_addr[4..6], 16)?;
        let third_oct = u8::from_str_radix(&hex_addr[2..4], 16)?;
        let fourth_oct = u8::from_str_radix(&hex_addr[..2], 16)?;

        Ok(format!(
            "{}.{}.{}.{}",
            first_oct, second_oct, third_oct, fourth_oct
        ))
    } else {
        Ok("".to_string())
    }
}