swage_core/util/
size.rs

1/// Memory size representation supporting common units.
2///
3/// This enum provides a convenient way to specify memory sizes in bytes, kilobytes,
4/// megabytes, or gigabytes. All units use binary (base-2) multipliers (1 KB = 1024 bytes).
5///
6/// # Examples
7///
8/// ```
9/// use swage_core::util::Size;
10///
11/// let size = Size::MB(4);
12/// assert_eq!(size.bytes(), 4 * 1024 * 1024);
13///
14/// let small = Size::KB(8);
15/// assert_eq!(small.bytes(), 8192);
16///
17/// let large = Size::GB(2);
18/// assert_eq!(large.bytes(), 2 * (1 << 30));
19/// ```
20#[derive(Clone, Copy, Debug)]
21pub enum Size {
22    /// Size in bytes
23    B(usize),
24    /// Size in kilobytes (1 KB = 1024 bytes)
25    KB(usize),
26    /// Size in megabytes (1 MB = 1024 KB)
27    MB(usize),
28    /// Size in gigabytes (1 GB = 1024 MB)
29    GB(usize),
30}
31
32impl Size {
33    /// Converts this size to bytes.
34    ///
35    /// # Examples
36    ///
37    /// ```
38    /// use swage_core::util::Size;
39    ///
40    /// assert_eq!(Size::B(100).bytes(), 100);
41    /// assert_eq!(Size::KB(1).bytes(), 1024);
42    /// assert_eq!(Size::MB(1).bytes(), 1048576);
43    /// assert_eq!(Size::GB(1).bytes(), 1073741824);
44    /// ```
45    pub const fn bytes(&self) -> usize {
46        match self {
47            Size::B(bytes) => *bytes,
48            Size::KB(kb) => *kb * (1 << 10),
49            Size::MB(mb) => *mb * (1 << 20),
50            Size::GB(gb) => *gb * (1 << 30),
51        }
52    }
53}
54
55impl std::fmt::Display for Size {
56    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57        match self {
58            Size::B(bytes) => write!(f, "{} B", bytes),
59            Size::KB(kb) => write!(f, "{} KB", kb),
60            Size::MB(mb) => write!(f, "{} MB", mb),
61            Size::GB(gb) => write!(f, "{} GB", gb),
62        }
63    }
64}
65
66#[cfg(test)]
67mod tests {
68    use crate::util::Size;
69
70    #[test]
71    fn size_conversions() {
72        let bytes = Size::B(12);
73        assert_eq!(bytes.bytes(), 12);
74        let mb = Size::MB(12);
75        assert_eq!(mb.bytes(), 12 * (1 << 20));
76        let gb = Size::GB(12);
77        assert_eq!(gb.bytes(), 12 * (1 << 30));
78    }
79}