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}