config-types 0.1.0

A library which provides ergononic types for configuration files
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
120
121

use regex::Regex;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default)]
pub struct ByteSizeConf(pub u64);

impl ByteSizeConf {
    pub fn as_bytes(&self) -> u64 {
        self.0
    }

    pub fn as_kilobytes(&self) -> u64 {
        self.0 / 1024
    }

    pub fn as_megabytes(&self) -> u64 {
        self.0 / 1024 / 1024
    }

    pub fn as_gigabytes(&self) -> u64 {
        self.0 / 1024 / 1024 / 1024
    }

    fn to_string(&self) -> String {
        let size = self.0;
        if size < 1024 {
            format!("{} bytes", size)
        } else if size < 2u64.pow(20) {
            format!("{} KiB", size / 1024)
        } else if size < 2u64.pow(30) {
            format!("{} MiB", size / 2u64.pow(20))
        } else {
            format!("{} GiB", size / 2u64.pow(30))
        }
    }
}

impl<'de> Deserialize<'de> for ByteSizeConf {
    fn deserialize<D>(deserializer: D) -> Result<ByteSizeConf, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        let size = parse_byte_size(&s).map_err(serde::de::Error::custom)?;
        Ok(ByteSizeConf(size))
    }
}

impl Serialize for ByteSizeConf {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        self.to_string().serialize(serializer)
    }
}

impl std::fmt::Display for ByteSizeConf {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

fn parse_byte_size(s: &str) -> Result<u64, String> {
    let re = Regex::new(r"^(\d+)\s*(b|kb|ki|mb|mi|gb|gi|tb|ti)$").map_err(|_| "Invalid regex")?;
    let s = s.to_lowercase();
    let caps = re
        .captures(s.as_str())
        .ok_or_else(|| format!("Invalid byte size: {}", s))?;
    let size = caps
        .get(1)
        .ok_or_else(|| "Invalid byte size".to_string())?
        .as_str()
        .parse()
        .map_err(|_| "Invalid byte size".to_string())?;
    let unit = caps
        .get(2)
        .ok_or_else(|| "Invalid byte size".to_string())?
        .as_str()
        .to_lowercase();
    let unit = unit.as_str();

    match unit {
        "b" => Ok(size),
        "kb" => Ok(size * 1000),
        "ki" => Ok(size * 2u64.pow(10)),
        "mb" => Ok(size * 10u64.pow(6)),
        "mi" => Ok(size * 2u64.pow(20)),
        "gb" => Ok(size * 10u64.pow(9)),
        "gi" => Ok(size * 2u64.pow(30)),
        "tb" => Ok(size * 10u64.pow(12)),
        "ti" => Ok(size * 2u64.pow(40)),
        _ => Err("Invalid byte size".to_string()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_byte_size() {
        assert_eq!(parse_byte_size("1b").unwrap(), 1);
        assert_eq!(parse_byte_size("1kb").unwrap(), 1000);
        assert_eq!(parse_byte_size("1ki").unwrap(), 1024);
        assert_eq!(parse_byte_size("1mb").unwrap(), 1000 * 1000);
        assert_eq!(parse_byte_size("1mi").unwrap(), 1024 * 1024);
        assert_eq!(parse_byte_size("1gb").unwrap(), 1000 * 1000 * 1000);
        assert_eq!(parse_byte_size("1gi").unwrap(), 1024 * 1024 * 1024);
        assert_eq!(parse_byte_size("1tb").unwrap(), 1000 * 1000 * 1000 * 1000);
        assert_eq!(parse_byte_size("1ti").unwrap(), 1024 * 1024 * 1024 * 1024);
    }

    #[test]
    fn test_byte_size_display() {
        assert_eq!(ByteSizeConf(1).to_string(), "1 bytes");
        assert_eq!(ByteSizeConf(1024).to_string(), "1 KiB");
        assert_eq!(ByteSizeConf(1024 * 1024).to_string(), "1 MiB");
        assert_eq!(ByteSizeConf(1024 * 1024 * 1024).to_string(), "1 GiB");
    }
}