refactor: Improve suffix handling for add and sub ops

Author: Techassi

crates/stackable-operator/src/quantity/mod.rs

@@ -142,6 +142,25 @@ impl Quantity {
             }
         }
     }
+
+    /// Either sets the suffix of `self` to `rhs` or scales `rhs` if `self` has a value other than
+    /// zero.
+    ///
+    /// This function is currently used for the [`std::ops::Add`] and [`std::ops::Sub`]
+    /// implementations.
+    pub fn set_suffix_or_scale_rhs(self, rhs: Self) -> (Self, Self) {
+        if self.value == 0.0 {
+            (
+                Self {
+                    suffix: rhs.suffix,
+                    ..self
+                },
+                rhs,
+            )
+        } else {
+            (self, rhs.scale_to(self.suffix))
+        }
+    }
 }
 
 #[cfg(test)]

crates/stackable-operator/src/quantity/ops.rs

@@ -6,11 +6,11 @@ impl Add for Quantity {
     type Output = Quantity;
 
     fn add(self, rhs: Quantity) -> Self::Output {
-        let rhs = rhs.scale_to(self.suffix);
+        let (this, rhs) = self.set_suffix_or_scale_rhs(rhs);
 
         Self {
-            value: self.value + rhs.value,
-            ..self
+            value: this.value + rhs.value,
+            suffix: this.suffix,
         }
     }
 }
@@ -25,11 +25,11 @@ impl Sub for Quantity {
     type Output = Quantity;
 
     fn sub(self, rhs: Quantity) -> Self::Output {
-        let rhs = rhs.scale_to(self.suffix);
+        let (this, rhs) = self.set_suffix_or_scale_rhs(rhs);
 
         Self {
-            value: self.value - rhs.value,
-            ..self
+            value: this.value - rhs.value,
+            suffix: this.suffix,
         }
     }
 }

crates/stackable-operator/src/quantity/suffix.rs

@@ -58,12 +58,12 @@ impl Suffix {
 
     pub fn scale_down(self) -> Option<Self> {
         match self {
-            Suffix::DecimalMultiple(s) => todo!(),
+            Suffix::DecimalMultiple(_s) => todo!(),
             Suffix::BinaryMultiple(s) => match s.scale_down() {
                 Some(s) => Some(Self::BinaryMultiple(s)),
                 None => Some(Self::DecimalMultiple(DecimalMultiple::Milli)),
             },
-            Suffix::DecimalExponent(s) => todo!(),
+            Suffix::DecimalExponent(_s) => todo!(),
         }
     }
 }