refactor: Use enum instead of bool

Author: sbernauer

crates/stackable-operator/src/role_utils.rs

@@ -415,20 +415,23 @@ where
     /// This is the case when all `replicas` are set to [`Some<u16>`], in which case they are simply
     /// summed.
     ///
-    /// The argument `treat_zero_as_none` is a safety mechanism, which allows the caller to decide
-    /// if an explicit replica count of `0` should be treated as [`None`]. It also means that
+    /// The argument `zero_replicas_counting` is a safety mechanism, which allows the caller to
+    /// decide if an explicit replica count of `0` should be treated as [`None`]. It also means that
     /// [`None`] is returned in case no roleGroups are configured at all.
-    pub fn fixed_replica_count(&self, treat_zero_as_none: bool) -> Option<u32> {
+    pub fn fixed_replica_count(
+        &self,
+        zero_replicas_counting: ZeroReplicasCounting,
+    ) -> Option<u32> {
         // An empty role has no fixed replica count when zeros are treated as None.
-        if treat_zero_as_none && self.role_groups.is_empty() {
+        if zero_replicas_counting == ZeroReplicasCounting::TreatAsNone && self.role_groups.is_empty() {
             return None;
         }
 
         self.role_groups
             .values()
             .map(|rg| match rg.replicas {
                 None => None,
-                Some(0) if treat_zero_as_none => None,
+                Some(0) if zero_replicas_counting == ZeroReplicasCounting::TreatAsNone => None,
                 // The individual replicas are [`u16`]s, so a [`u32`] sum has plenty of space.
                 Some(replicas) => Some(u32::from(replicas)),
             })
@@ -448,6 +451,15 @@ where
     }
 }
 
+/// How explicit zero (`0`) replicas on a role group should be counted
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ZeroReplicasCounting {
+    /// Treat them as what they are: `Some(0)`.
+    TreatAsZero,
+    /// Treat them as if the user configured [`None`].
+    TreatAsNone,
+}
+
 impl<Config, ConfigOverrides, RoleConfig>
     Role<Config, ConfigOverrides, RoleConfig, JavaCommonConfig>
 where
@@ -704,45 +716,45 @@ mod tests {
     fn replica_counts_with_all_replicas_set() {
         let role = construct_role_with_replicas([Some(3), Some(2), Some(5)]);
 
-        assert_eq!(role.fixed_replica_count(false), Some(10));
-        assert_eq!(role.fixed_replica_count(true), Some(10));
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(10));
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), Some(10));
         assert_eq!(role.estimated_replica_count(), 10);
     }
 
     #[test]
     fn replica_counts_with_one_replica_unset() {
         let role = construct_role_with_replicas([Some(3), None, Some(2)]);
 
-        assert_eq!(role.fixed_replica_count(false), None);
-        assert_eq!(role.fixed_replica_count(true), None);
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), None);
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None);
         assert_eq!(role.estimated_replica_count(), 6);
     }
 
     #[test]
     fn replica_counts_with_a_zero_replica() {
         let role = construct_role_with_replicas([Some(3), Some(0)]);
 
-        assert_eq!(role.fixed_replica_count(false), Some(3));
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(3));
         // With treat_zero_as_none the zero turns the whole count into None.
-        assert_eq!(role.fixed_replica_count(true), None);
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None);
         assert_eq!(role.estimated_replica_count(), 3);
     }
 
     #[test]
     fn replica_counts_with_a_single_zero_role_group() {
         let role = construct_role_with_replicas([Some(0)]);
 
-        assert_eq!(role.fixed_replica_count(false), Some(0));
-        assert_eq!(role.fixed_replica_count(true), None);
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(0));
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None);
         assert_eq!(role.estimated_replica_count(), 0);
     }
 
     #[test]
     fn replica_counts_without_role_groups() {
         let role = construct_role_with_replicas(vec![]);
 
-        assert_eq!(role.fixed_replica_count(false), Some(0));
-        assert_eq!(role.fixed_replica_count(true), None);
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(0));
+        assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None);
         assert_eq!(role.estimated_replica_count(), 0);
     }