wip: Switch device

Author: Techassi

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

@@ -31,6 +31,20 @@ pub enum ParseQuantityError {
     InvalidSuffix { source: ParseSuffixError },
 }
 
+// pub struct CpuQuant(Quantity1<DecimalMultiple>);
+
+// pub struct Quantity1<T>
+// where
+//     T: SuffixTrait,
+// {
+//     value: f64,
+//     suffix: T,
+// }
+
+// pub trait SuffixTrait: FromStr + Default {
+//     fn factor(&self) -> f64;
+// }
+
 /// Quantity is a representation of a number with a suffix / format.
 ///
 /// This type makes it possible to parse Kubernetes quantity strings like '12Ki', '2M, '1.5e2', or
@@ -208,6 +222,28 @@ impl Quantity {
         }
     }
 
+    pub fn scale_to_non_zero(self) -> Self {
+        if !self.value.between(-1.0, 1.0) {
+            return self;
+        }
+
+        let mut this = self;
+
+        while let Some(suffix) = this.suffix.scale_down() {
+            this = self.scale_to(suffix);
+            if this.value.between(-1.0, 1.0) {
+                continue;
+            } else {
+                return this;
+            }
+        }
+
+        Self {
+            value: 1.0,
+            suffix: this.suffix,
+        }
+    }
+
     /// Either sets the suffix of `self` to `rhs` or scales `rhs` if `self` has a value other than
     /// zero.
     ///
@@ -228,46 +264,54 @@ impl Quantity {
     }
 }
 
+trait FloatExt: PartialOrd + Sized {
+    fn between(self, start: Self, end: Self) -> bool {
+        self > start && self < end
+    }
+}
+
+impl FloatExt for f64 {}
+
 #[cfg(test)]
 mod test {
     use super::*;
     use rstest::rstest;
 
+    // See https://github.com/kubernetes/apimachinery/blob/3e8e52d6a1259ada73f63c1c7d1fad39d4ba9fb4/pkg/api/resource/quantity_test.go#L276-L287
+    #[rustfmt::skip]
     #[rstest]
-    #[case("49041204Ki", Quantity { value: 49041204.0, suffix: Suffix::BinaryMultiple(BinaryMultiple::Kibi) })]
-    #[case("256Ki", Quantity { value: 256.0, suffix: Suffix::BinaryMultiple(BinaryMultiple::Kibi) })]
-    #[case("1.5Gi", Quantity { value: 1.5, suffix: Suffix::BinaryMultiple(BinaryMultiple::Gibi) })]
-    #[case("0.8Ti", Quantity { value: 0.8, suffix: Suffix::BinaryMultiple(BinaryMultiple::Tebi) })]
-    #[case("3.2Pi", Quantity { value: 3.2, suffix: Suffix::BinaryMultiple(BinaryMultiple::Pebi) })]
-    #[case("0.2Ei", Quantity { value: 0.2, suffix: Suffix::BinaryMultiple(BinaryMultiple::Exbi) })]
-    #[case("8Mi", Quantity { value: 8.0, suffix: Suffix::BinaryMultiple(BinaryMultiple::Mebi) })]
-    fn binary_quantity_from_str_pass(#[case] input: &str, #[case] expected: Quantity) {
+    #[case("0",   0.0, Suffix::DecimalMultiple(DecimalMultiple::Empty))]
+    #[case("0n",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Nano))]
+    #[case("0u",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Micro))]
+    #[case("0m",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Milli))]
+    #[case("0Ki", 0.0, Suffix::BinaryMultiple(BinaryMultiple::Kibi))]
+    #[case("0k",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Kilo))]
+    #[case("0Mi", 0.0, Suffix::BinaryMultiple(BinaryMultiple::Mebi))]
+    #[case("0M",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Mega))]
+    #[case("0Gi", 0.0, Suffix::BinaryMultiple(BinaryMultiple::Gibi))]
+    #[case("0G",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Giga))]
+    #[case("0Ti", 0.0, Suffix::BinaryMultiple(BinaryMultiple::Tebi))]
+    #[case("0T",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Tera))]
+    #[case("0Pi", 0.0, Suffix::BinaryMultiple(BinaryMultiple::Pebi))]
+    #[case("0P",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Peta))]
+    #[case("0Ei", 0.0, Suffix::BinaryMultiple(BinaryMultiple::Exbi))]
+    #[case("0E",  0.0, Suffix::DecimalMultiple(DecimalMultiple::Exa))]
+    fn parse_zero_quantity(#[case] input: &str, #[case] expected_value: f64, #[case] expected_suffix: Suffix) {
         let parsed = Quantity::from_str(input).unwrap();
-        assert_eq!(parsed, expected);
-    }
 
-    #[rstest]
-    #[case("49041204k", Quantity { value: 49041204.0, suffix: Suffix::DecimalMultiple(DecimalMultiple::Kilo) })]
-    #[case("256k", Quantity { value: 256.0, suffix: Suffix::DecimalMultiple(DecimalMultiple::Kilo) })]
-    #[case("1.5G", Quantity { value: 1.5, suffix: Suffix::DecimalMultiple(DecimalMultiple::Giga) })]
-    #[case("0.8T", Quantity { value: 0.8, suffix: Suffix::DecimalMultiple(DecimalMultiple::Tera) })]
-    #[case("3.2P", Quantity { value: 3.2, suffix: Suffix::DecimalMultiple(DecimalMultiple::Peta) })]
-    #[case("0.2E", Quantity { value: 0.2, suffix: Suffix::DecimalMultiple(DecimalMultiple::Exa) })]
-    #[case("4m", Quantity { value: 4.0, suffix: Suffix::DecimalMultiple(DecimalMultiple::Milli) })]
-    #[case("8M", Quantity { value: 8.0, suffix: Suffix::DecimalMultiple(DecimalMultiple::Mega) })]
-    fn decimal_quantity_from_str_pass(#[case] input: &str, #[case] expected: Quantity) {
-        let parsed = Quantity::from_str(input).unwrap();
-        assert_eq!(parsed, expected);
+        assert_eq!(parsed.suffix, expected_suffix);
+        assert_eq!(parsed.value, expected_value);
     }
 
+    // See https://github.com/kubernetes/apimachinery/blob/3e8e52d6a1259ada73f63c1c7d1fad39d4ba9fb4/pkg/api/resource/quantity_test.go#L289
+    #[rustfmt::skip]
     #[rstest]
-    #[case("1.234e-3.21", Quantity { value: 1.234, suffix: Suffix::DecimalExponent(DecimalExponent::from(-3.21)) })]
-    #[case("1.234E-3.21", Quantity { value: 1.234, suffix: Suffix::DecimalExponent(DecimalExponent::from(-3.21)) })]
-    #[case("1.234e3", Quantity { value: 1.234, suffix: Suffix::DecimalExponent(DecimalExponent::from(3.0)) })]
-    #[case("1.234E3", Quantity { value: 1.234, suffix: Suffix::DecimalExponent(DecimalExponent::from(3.0)) })]
-    fn decimal_exponent_quantity_from_str_pass(#[case] input: &str, #[case] expected: Quantity) {
+    #[case("12.34", 12.34)]
+    #[case("12",    12.0)]
+    #[case("1",      1.0)]
+    fn parse_quantity_without_suffix(#[case] input: &str, #[case] expected_value: f64) {
         let parsed = Quantity::from_str(input).unwrap();
-        assert_eq!(parsed, expected);
+        assert_eq!(parsed.value, expected_value);
     }
 
     #[rstest]

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

@@ -181,6 +181,7 @@ pub enum DecimalMultiple {
     #[strum(serialize = "")]
     Empty,
 
+    // (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)
     #[strum(serialize = "k")]
     Kilo,