feat: display type

Author: robjtede

examples/ls.rs

@@ -15,7 +15,7 @@ fn main() -> io::Result<()> {
 
         if md.is_file() {
             let file_size = md.len();
-            let file_size = bytesize::ByteSize::b(file_size);
+            let file_size = bytesize::ByteSize::b(file_size).display().short();
 
             println!("{file_size}\t{file_name}");
         } else {

src/display.rs

@@ -0,0 +1,132 @@
+use core::{fmt, write};
+
+use crate::ByteSize;
+
+#[derive(Debug, Clone)]
+pub(crate) enum Style {
+    IEC,
+    SI,
+    Short,
+}
+
+#[derive(Debug, Clone)]
+pub struct Display {
+    pub(crate) byte_size: ByteSize,
+    pub(crate) style: Style,
+}
+
+impl Display {
+    pub fn iec(mut self) -> Self {
+        self.style = Style::IEC;
+        self
+    }
+
+    pub fn si(mut self) -> Self {
+        self.style = Style::SI;
+        self
+    }
+
+    pub fn short(mut self) -> Self {
+        self.style = Style::Short;
+        self
+    }
+}
+
+impl fmt::Display for Display {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let bytes = self.byte_size.as_u64();
+
+        let unit = match self.style {
+            Style::IEC | Style::Short => crate::KIB,
+            Style::SI => crate::KB,
+        };
+        let unit_base = match self.style {
+            Style::IEC | Style::Short => crate::LN_KIB,
+            Style::SI => crate::LN_KB,
+        };
+
+        let unit_prefixes = match self.style {
+            Style::IEC | Style::Short => crate::UNITS_IEC.as_bytes(),
+            Style::SI => crate::UNITS_SI.as_bytes(),
+        };
+        let unit_separator = match self.style {
+            Style::IEC | Style::SI => " ",
+            Style::Short => "",
+        };
+        let unit_suffix = match self.style {
+            Style::IEC => "iB",
+            Style::SI => "B",
+            Style::Short => "",
+        };
+
+        if bytes < unit {
+            write!(f, "{bytes}{unit_separator}B")?;
+        } else {
+            let size = bytes as f64;
+            let exp = match (size.ln() / unit_base) as usize {
+                0 => 1,
+                e => e,
+            };
+
+            let unit_prefix = unit_prefixes[exp - 1] as char;
+
+            write!(
+                f,
+                "{:.1}{unit_separator}{unit_prefix}{unit_suffix}",
+                (size / unit.pow(exp as u32) as f64),
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn to_string_iec() {
+        let display = Display {
+            byte_size: ByteSize::gib(1),
+            style: Style::IEC,
+        };
+        assert_eq!("1.0 GiB", display.to_string());
+
+        let display = Display {
+            byte_size: ByteSize::gb(1),
+            style: Style::IEC,
+        };
+        assert_eq!("953.7 MiB", display.to_string());
+    }
+
+    #[test]
+    fn to_string_si() {
+        let display = Display {
+            byte_size: ByteSize::gib(1),
+            style: Style::SI,
+        };
+        assert_eq!("1.1 GB", display.to_string());
+
+        let display = Display {
+            byte_size: ByteSize::gb(1),
+            style: Style::SI,
+        };
+        assert_eq!("1.0 GB", display.to_string());
+    }
+
+    #[test]
+    fn to_string_short() {
+        let display = Display {
+            byte_size: ByteSize::gib(1),
+            style: Style::Short,
+        };
+        assert_eq!("1.0G", display.to_string());
+
+        let display = Display {
+            byte_size: ByteSize::gb(1),
+            style: Style::Short,
+        };
+        assert_eq!("953.7M", display.to_string());
+    }
+}

src/lib.rs

@@ -40,18 +40,20 @@
 //! assert_eq!(ByteSize::gb(996), minus);
 //! ```
 
+use std::fmt::{self, Debug, Display, Formatter};
+use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
+
 #[cfg(feature = "arbitrary")]
 mod arbitrary;
+mod display;
 mod parse;
 #[cfg(feature = "serde")]
 mod serde;
 
-use std::fmt::{self, Debug, Display, Formatter};
-use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
-
 /// byte size for 1 byte
 pub const B: u64 = 1;
 /// bytes size for 1 kilobyte
+/// Number of bytes in 1 kilobyte.
 pub const KB: u64 = 1_000;
 /// bytes size for 1 megabyte
 pub const MB: u64 = 1_000_000;
@@ -136,8 +138,8 @@ pub fn pib<V: Into<u64>>(size: V) -> u64 {
     size.into() * PIB
 }
 
-/// Byte size representation
-#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
+/// Byte size representation.
+#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ByteSize(pub u64);
 
 impl ByteSize {
@@ -201,6 +203,13 @@ impl ByteSize {
         self.0
     }
 
+    pub fn display(&self) -> crate::display::Display {
+        crate::display::Display {
+            byte_size: *self,
+            style: crate::display::Style::IEC,
+        }
+    }
+
     #[inline(always)]
     pub fn to_string_as(&self, si_unit: bool) -> String {
         to_string(self.0, si_unit)