feat: always show units and add display impl

Author: c-git

src/app/data_display_options.rs

@@ -1,6 +1,8 @@
-use std::collections::{BTreeMap, BTreeSet};
-
-use egui::Color32;
+use egui::{Color32, WidgetText};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fmt::Display,
+};
 
 #[derive(serde::Deserialize, serde::Serialize, Debug, PartialEq, Eq)]
 #[serde(default)] // if we add new fields, give them default values when deserializing old state
@@ -65,48 +67,72 @@ pub struct RowSizeConfig {
     pub units: SizeUnits,
 }
 
-#[derive(Default, serde::Deserialize, serde::Serialize, Debug, PartialEq, Eq)]
+#[derive(Default, serde::Deserialize, serde::Serialize, Debug, PartialEq, Eq, Clone, Copy)]
 pub enum SizeUnits {
     Bytes,
     KB,
     MB,
     GB,
     TB,
     #[default]
-    /// Is output as a String because it includes the unit and is the largest unit where the output value is >= 1
     Auto,
 }
+
 impl SizeUnits {
-    pub(crate) fn convert(&self, row_size_in_bytes: usize) -> serde_json::Value {
-        let scalar = match self {
+    fn to_concrete(self, row_size_in_bytes: usize) -> Self {
+        if !matches!(self, Self::Auto) {
+            // Easy case where type is specified
+            return self;
+        }
+
+        // Determine which unit to use when using auto
+        let units = [Self::Bytes, Self::KB, Self::MB, Self::GB, Self::TB];
+        let mut last_index = 0;
+        let row_size_in_bytes = row_size_in_bytes as f64;
+        for (i, unit) in units.iter().enumerate().skip(1) {
+            if (row_size_in_bytes / unit.scalar()) >= 1.0 {
+                last_index = i;
+            } else {
+                // Last was as correct unit
+                break;
+            }
+        }
+        units[last_index]
+    }
+
+    /// Returns the scalar for that unit
+    ///
+    /// Panics: if unit is [`Self::Auto`]
+    fn scalar(&self) -> f64 {
+        match self {
             SizeUnits::Bytes => 1.0,
             SizeUnits::KB => 1024.0,
             SizeUnits::MB => 1024.0 * 1024.0,
             SizeUnits::GB => 1024.0 * 1024.0 * 1024.0,
             SizeUnits::TB => 1024.0 * 1024.0 * 1024.0 * 1024.0,
             SizeUnits::Auto => {
-                // TODO 5: Rewrite with shifts for performance
-                // Special handling see doc string for explanation
-                let units = ["Bytes", "KB", "MB", "GB", "TB"];
-                let mut last_index = 0;
-                let mut scalar = 1.0f64;
-                let row_size_in_bytes = row_size_in_bytes as f64;
-                for i in 1..units.len() {
-                    let new_scalar = scalar * 1024.0;
-                    if (row_size_in_bytes / new_scalar) >= 1.0 {
-                        last_index = i;
-                        scalar = new_scalar;
-                    } else {
-                        // Last was as correct unit
-                        break;
-                    }
-                }
-                let result = row_size_in_bytes / scalar;
-                return format!("{result:0>9.4} {}", units[last_index]).into();
+                unreachable!("precondition violated: Auto does not have a scalar")
             }
-        };
+        }
+    }
+
+    /// Output as a string because includes the unit
+    pub(crate) fn convert(&self, row_size_in_bytes: usize) -> serde_json::Value {
+        let concrete_unit = self.to_concrete(row_size_in_bytes);
+        let scalar = concrete_unit.scalar();
         let result = row_size_in_bytes as f64 / scalar;
-        result.into()
+        format!("{result:0>9.4} {concrete_unit}").into()
+    }
+
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            SizeUnits::Bytes => "Bytes",
+            SizeUnits::KB => "KB",
+            SizeUnits::MB => "MB",
+            SizeUnits::GB => "GB",
+            SizeUnits::TB => "TB",
+            SizeUnits::Auto => "Auto",
+        }
     }
 }
 
@@ -222,3 +248,15 @@ impl Default for LevelConversion {
         }
     }
 }
+
+impl Display for SizeUnits {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<SizeUnits> for WidgetText {
+    fn from(value: SizeUnits) -> Self {
+        value.as_str().into()
+    }
+}