Remove percentage Raw. Just work with f64 if unvalidated is needed

Author: mineichen

CHANGELOG.md

@@ -1,4 +1,4 @@
-:w
 #v0.2
 - Add `RelativeResourcePath` and `RelativeResourcePathBuf`. Deprecate `RelativeFilePath`, as it's name was misleading (it contained a PathBuf)
 - `RelativeDirPathError` and `RelativeFilePathError` changed from containing `String` to the constructor input type
+- Remove `sealedstruct::Seal` from Percentage, thus remove PercentageRaw

flake.lock

@@ -16,8 +16,8 @@ impl RelativePolygon {
             .iter()
             .map(|(col_rel, row_rel)| {
                 (
-                    (col_rel.into_inner().value() * x_dist + 0.5) as u32,
-                    (row_rel.into_inner().value() * y_dist + 0.5) as u32,
+                    (col_rel.value() * x_dist + 0.5) as u32,
+                    (row_rel.value() * y_dist + 0.5) as u32,
                 )
             })
             .collect::<Vec<_>>()

pilatus-engineering/src/spatial/relative_polygon.rs

@@ -20,10 +20,10 @@ impl RelativeRectangle {
         let x_dist = (dimensions.0.get() - 1) as f64;
         let y_dist = (dimensions.1.get() - 1) as f64;
 
-        let col1 = **self.column.from * x_dist + 0.5;
-        let row1 = **self.row.from * y_dist + 0.5;
-        let col2 = **self.column.to * x_dist + 0.5;
-        let row2 = **self.row.to * y_dist + 0.5;
+        let col1 = *self.column.from * x_dist + 0.5;
+        let row1 = *self.row.from * y_dist + 0.5;
+        let col2 = *self.column.to * x_dist + 0.5;
+        let row2 = *self.row.to * y_dist + 0.5;
 
         [col1 as u32, row1 as u32, col2 as u32, row2 as u32]
     }

pilatus-engineering/src/spatial/relative_rectangle.rs

@@ -5,64 +5,69 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
-#[derive(PartialEq, PartialOrd, Clone, Copy, Serialize, Deserialize, sealedstruct::Seal)]
-pub struct PercentageRaw(f64);
+#[derive(PartialEq, PartialOrd, Clone, Copy, Serialize, Deserialize)]
+#[serde(try_from = "f64")]
+pub struct Percentage(f64);
 
 #[cfg(feature = "impex")]
 impl impex::ImpexPrimitive for Percentage {}
 
-impl sealedstruct::Validator for PercentageRaw {
-    fn check(&self) -> sealedstruct::Result<()> {
-        if **self < 0. {
-            return sealedstruct::ValidationError::new(format!("{} is too small", self.0)).into();
-        }
+#[derive(Debug, thiserror::Error)]
+#[error("Invalid percentage {0}")]
+pub struct InvalidPercentage(f64);
+
+impl TryFrom<f64> for Percentage {
+    type Error = InvalidPercentage;
 
-        if **self > 1. {
-            return sealedstruct::ValidationError::new(format!("{} is too big", self.0)).into();
+    fn try_from(value: f64) -> Result<Self, Self::Error> {
+        if ((0.)..=1.).contains(&value) {
+            Ok(Percentage(value))
+        } else {
+            Err(InvalidPercentage(value))
         }
-        Ok(())
     }
 }
 
 impl Percentage {
-    pub fn new(i: f64) -> sealedstruct::Result<Self> {
-        PercentageRaw(i).seal()
+    pub const fn new(value: f64) -> Option<Self> {
+        if value >= 0. && value <= 1. {
+            Some(Percentage(value))
+        } else {
+            None
+        }
     }
-    pub fn max() -> Self {
-        Percentage::new_unchecked(PercentageRaw(1.0))
+
+    pub const fn max() -> Self {
+        Percentage(1.0)
     }
-    pub fn min() -> Self {
-        Percentage::new_unchecked(PercentageRaw(0.0))
+    pub const fn min() -> Self {
+        Percentage(0.0)
     }
 
     pub fn fifty() -> Self {
-        Percentage::new_unchecked(PercentageRaw(0.5))
+        Percentage(0.5)
     }
 }
 
-impl approx::AbsDiffEq for PercentageRaw {
+impl approx::AbsDiffEq for Percentage {
     type Epsilon = f64;
 
     fn default_epsilon() -> Self::Epsilon {
         f64::EPSILON
     }
 
     fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool {
-        self.0.abs_diff_eq(other, epsilon)
+        self.0.abs_diff_eq(&other.0, epsilon)
     }
 }
 
-impl PercentageRaw {
-    pub fn new(i: f64) -> Self {
-        Self(i)
-    }
-
+impl Percentage {
     pub fn value(&self) -> f64 {
         self.0
     }
 }
 
-impl Display for PercentageRaw {
+impl Display for Percentage {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_fmt(format_args!("{}%", self.0 * 100.))
     }
@@ -74,42 +79,22 @@ impl Debug for Percentage {
     }
 }
 
-impl std::ops::Sub for PercentageRaw {
-    type Output = PercentageRaw;
+impl std::ops::Mul<f64> for Percentage {
+    type Output = f64;
 
-    fn sub(self, rhs: Self) -> Self::Output {
-        PercentageRaw(self.0 - rhs.0)
+    fn mul(self, rhs: f64) -> Self::Output {
+        self.0 * rhs
     }
 }
-
-impl std::ops::Add for PercentageRaw {
-    type Output = PercentageRaw;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        PercentageRaw(self.0 + rhs.0)
-    }
-}
-
-impl std::ops::Mul for PercentageRaw {
-    type Output = PercentageRaw;
+impl std::ops::Mul for Percentage {
+    type Output = Percentage;
 
     fn mul(self, rhs: Self) -> Self::Output {
-        PercentageRaw(self.0 * rhs.0)
-    }
-}
-
-impl From<f64> for Percentage {
-    fn from(i: f64) -> Self {
-        Self(i.into())
-    }
-}
-impl From<f64> for PercentageRaw {
-    fn from(i: f64) -> Self {
-        Self(i)
+        Percentage(self.0 * rhs.0)
     }
 }
 
-impl Deref for PercentageRaw {
+impl Deref for Percentage {
     type Target = f64;
 
     fn deref(&self) -> &Self::Target {
@@ -123,7 +108,7 @@ mod tests {
 
     #[test]
     fn invalid_percentage() {
-        assert!(PercentageRaw::new(-1.).seal().is_err());
-        assert!(PercentageRaw::new(1.1).seal().is_err());
+        assert!(Percentage::new(-1.).is_none());
+        assert!(Percentage::new(1.1).is_none());
     }
 }

pilatus/src/relative/percentage.rs

@@ -1,3 +1,5 @@
+use std::{fmt::Display};
+
 use serde::{Deserialize, Serialize};
 
 use super::Percentage;
@@ -53,11 +55,13 @@ impl RelativeRange {
     ) -> (Option<RelativeRange>, RelativeRange, Option<RelativeRange>) {
         let width_percentage = *self.to - *self.from;
         let from_split_position = (*self.from + width_percentage * *range.from)
-            .seal()
+            .try_into()
+            .unwrap();
+        let to_split_position = (*self.from + width_percentage * *range.to)
+            .try_into()
             .unwrap();
-        let to_split_position = (*self.from + width_percentage * *range.to).seal().unwrap();
 
-        let left = (**range.from > 0.).then(|| {
+        let left = (*range.from > 0.).then(|| {
             RelativeRangeRaw {
                 from: self.from,
                 to: from_split_position,
@@ -73,7 +77,7 @@ impl RelativeRange {
         .seal()
         .unwrap();
 
-        let right = (**range.to < 1.).then(|| {
+        let right = (*range.to < 1.).then(|| {
             RelativeRangeRaw {
                 from: to_split_position,
                 to: self.to,
@@ -88,12 +92,16 @@ impl RelativeRange {
 
 impl RelativeRange {
     pub fn new(
-        from: impl Into<Percentage>,
-        to: impl Into<Percentage>,
+        from: impl TryInto<Percentage, Error: Display>,
+        to: impl TryInto<Percentage, Error: Display>,
     ) -> sealedstruct::Result<Self> {
         RelativeRangeRaw {
-            from: from.into(),
-            to: to.into(),
+            from: from
+                .try_into()
+                .map_err(|x| sealedstruct::ValidationError::new(format!("Invalid from {x}")))?,
+            to: to
+                .try_into()
+                .map_err(|x| sealedstruct::ValidationError::new(format!("Invalid to {x}")))?,
         }
         .seal()
     }