feat: Add support for math ops

Author: Techassi

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

@@ -3,7 +3,8 @@ use std::{ops::Deref, str::FromStr};
 use k8s_openapi::apimachinery::pkg::api::resource::Quantity as K8sQuantity;
 
 use crate::quantity::{
-    macros::forward_from_impls, DecimalByteMultiple, ParseQuantityError, Quantity, Suffix,
+    macros::{forward_from_impls, forward_op_impls},
+    DecimalByteMultiple, ParseQuantityError, Quantity, Suffix,
 };
 
 #[derive(Clone, Debug, PartialEq)]
@@ -27,6 +28,16 @@ impl FromStr for CpuQuantity {
 }
 
 forward_from_impls!(Quantity, K8sQuantity, CpuQuantity);
+forward_op_impls!(
+    CpuQuantity(Quantity {
+        value: 0.0,
+        suffix: None,
+    }),
+    CpuQuantity,
+    usize,
+    f32,
+    f64
+);
 
 impl CpuQuantity {
     pub fn from_millis(value: u32) -> Self {

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

@@ -0,0 +1,104 @@
+/// This macro is intended to be used to implement the From and TryFrom traits on specialized
+/// quantities.
+///
+/// Currently two specialized quantities exist: [`MemoryQuantity`][1] and [`CpuQuantity`][2].
+/// The traits are implemented by forwarding to the inner [`Quantity`][3] implementation. Both
+/// specialized quantities are just newtypes / wrappers around [`Quantity`][3].
+///
+/// [1]: super::MemoryQuantity
+/// [2]: super::CpuQuantity
+/// [3]: super::Quantity
+macro_rules! forward_from_impls {
+    ($q:ty, $kq:ty, $for:ty) => {
+        impl From<$q> for $for {
+            fn from(quantity: $q) -> Self {
+                Self(quantity)
+            }
+        }
+
+        impl TryFrom<$kq> for $for {
+            type Error = ParseQuantityError;
+
+            fn try_from(value: $kq) -> Result<Self, Self::Error> {
+                Ok(Self(Quantity::try_from(value)?))
+            }
+        }
+
+        impl TryFrom<&$kq> for $for {
+            type Error = ParseQuantityError;
+
+            fn try_from(value: &$kq) -> Result<Self, Self::Error> {
+                Ok(Self(Quantity::try_from(value)?))
+            }
+        }
+    };
+}
+
+macro_rules! forward_op_impls {
+    ($acc:expr, $for:ty, $($on:ty),+) => {
+        impl ::std::ops::Add for $for {
+            type Output = $for;
+
+            fn add(self, rhs: $for) -> Self::Output {
+                Self(self.0 + rhs.0)
+            }
+        }
+
+        impl ::std::ops::AddAssign for $for {
+            fn add_assign(&mut self, rhs: $for) {
+                self.0 += rhs.0
+            }
+        }
+
+        impl ::std::ops::Sub for $for {
+            type Output = $for;
+
+            fn sub(self, rhs: $for) -> Self::Output {
+                Self(self.0 - rhs.0)
+            }
+        }
+
+        impl ::std::ops::SubAssign for $for {
+            fn sub_assign(&mut self, rhs: $for) {
+                self.0 -= rhs.0
+            }
+        }
+
+        impl ::std::ops::Div for $for {
+            type Output = f64;
+
+            fn div(self, rhs: $for) -> Self::Output {
+                self.0 / rhs.0
+            }
+        }
+
+        impl ::std::iter::Sum for $for {
+            fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+                iter.fold(
+                    $acc,
+                    <$for as ::std::ops::Add>::add,
+                )
+            }
+        }
+
+        $(
+            impl ::std::ops::Mul<$on> for $for {
+                type Output = $for;
+
+                fn mul(self, rhs: $on) -> Self::Output {
+                    Self(self.0 * rhs)
+                }
+            }
+
+            impl ::std::ops::MulAssign<$on> for $for {
+                fn mul_assign(&mut self, rhs: $on) {
+                    self.0 *= rhs
+                }
+            }
+        )*
+    };
+}
+
+/// HACK: Make the macros only available in this crate.
+pub(crate) use forward_from_impls;
+pub(crate) use forward_op_impls;

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

@@ -3,7 +3,8 @@ use std::{ops::Deref, str::FromStr};
 use k8s_openapi::apimachinery::pkg::api::resource::Quantity as K8sQuantity;
 
 use crate::quantity::{
-    macros::forward_from_impls, BinaryByteMultiple, ParseQuantityError, Quantity, Suffix,
+    macros::{forward_from_impls, forward_op_impls},
+    BinaryByteMultiple, ParseQuantityError, Quantity, Suffix,
 };
 
 pub trait JavaHeap {
@@ -35,6 +36,18 @@ impl FromStr for MemoryQuantity {
 }
 
 forward_from_impls!(Quantity, K8sQuantity, MemoryQuantity);
+forward_op_impls!(
+    MemoryQuantity(Quantity {
+        value: 0.0,
+        // TODO (@Techassi): This needs to be talked about. The previous implementation used Kibi
+        // here. Code which relies on that fact (for later scaling) will thus break.
+        suffix: None,
+    }),
+    MemoryQuantity,
+    usize,
+    f32,
+    f64
+);
 
 impl MemoryQuantity {
     pub const fn from_gibi(value: f64) -> Self {

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

@@ -9,7 +9,9 @@ use k8s_openapi::apimachinery::pkg::api::resource::Quantity as K8sQuantity;
 use snafu::{ensure, ResultExt as _, Snafu};
 
 mod cpu;
+mod macros;
 mod memory;
+mod ops;
 
 pub use cpu::*;
 pub use memory::*;
@@ -369,36 +371,6 @@ impl SuffixMultiple for DecimalExponent {
     }
 }
 
-mod macros {
-    macro_rules! forward_from_impls {
-        ($q:ty, $kq:ty, $for:ty) => {
-            impl From<$q> for $for {
-                fn from(quantity: $q) -> Self {
-                    Self(quantity)
-                }
-            }
-
-            impl TryFrom<$kq> for $for {
-                type Error = ParseQuantityError;
-
-                fn try_from(value: $kq) -> Result<Self, Self::Error> {
-                    Ok(Self(Quantity::try_from(value)?))
-                }
-            }
-
-            impl TryFrom<&$kq> for $for {
-                type Error = ParseQuantityError;
-
-                fn try_from(value: &$kq) -> Result<Self, Self::Error> {
-                    Ok(Self(Quantity::try_from(value)?))
-                }
-            }
-        };
-    }
-
-    pub(crate) use forward_from_impls;
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

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

@@ -0,0 +1,111 @@
+use std::{
+    iter::Sum,
+    ops::{Add, AddAssign, Div, Mul, MulAssign, Sub, SubAssign},
+};
+
+use crate::quantity::Quantity;
+
+impl Add for Quantity {
+    type Output = Quantity;
+
+    fn add(self, rhs: Quantity) -> Self::Output {
+        Self {
+            value: self.value + rhs.value,
+            ..self
+        }
+    }
+}
+
+impl AddAssign for Quantity {
+    fn add_assign(&mut self, rhs: Quantity) {
+        self.value += rhs.value
+    }
+}
+
+impl Sub for Quantity {
+    type Output = Quantity;
+
+    fn sub(self, rhs: Quantity) -> Self::Output {
+        Self {
+            value: self.value - rhs.value,
+            ..self
+        }
+    }
+}
+
+impl SubAssign for Quantity {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.value -= rhs.value
+    }
+}
+
+impl Mul<usize> for Quantity {
+    type Output = Quantity;
+
+    fn mul(self, rhs: usize) -> Self::Output {
+        Self {
+            value: self.value * rhs as f64,
+            ..self
+        }
+    }
+}
+
+impl MulAssign<usize> for Quantity {
+    fn mul_assign(&mut self, rhs: usize) {
+        self.value *= rhs as f64
+    }
+}
+
+impl Mul<f32> for Quantity {
+    type Output = Quantity;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self {
+            value: self.value * rhs as f64,
+            ..self
+        }
+    }
+}
+
+impl MulAssign<f32> for Quantity {
+    fn mul_assign(&mut self, rhs: f32) {
+        self.value *= rhs as f64
+    }
+}
+
+impl Mul<f64> for Quantity {
+    type Output = Quantity;
+
+    fn mul(self, rhs: f64) -> Self::Output {
+        Self {
+            value: self.value * rhs,
+            ..self
+        }
+    }
+}
+
+impl MulAssign<f64> for Quantity {
+    fn mul_assign(&mut self, rhs: f64) {
+        self.value *= rhs
+    }
+}
+
+impl Div for Quantity {
+    type Output = f64;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        self.value / rhs.value
+    }
+}
+
+impl Sum for Quantity {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(
+            Quantity {
+                value: 0.0,
+                suffix: None,
+            },
+            Quantity::add,
+        )
+    }
+}