simplify missingvaluerange

diff --git a/rust/pspp/src/sys/raw.rs b/rust/pspp/src/sys/raw.rs
index fe13fe3fdb5bd57338fcf5f3a7c08b077280c710..2a9113a736659822b510e67ed837ec247328dfce 100644 (file)
--- a/rust/pspp/src/sys/raw.rs
+++ b/rust/pspp/src/sys/raw.rs
@@ -1129,17 +1129,39 @@ where
     pub values: Vec<Value<S>>,
 
     /// Optional range of missing values.
-    pub range: Option<MissingValueRange<S>>,
+    pub range: Option<MissingValueRange>,
 }
 
-#[derive(Clone)]
-pub enum MissingValueRange<S = Box<[u8]>>
-where
-    S: Debug,
-{
-    In { low: Value<S>, high: Value<S> },
-    From { low: Value<S> },
-    To { high: Value<S> },
+#[derive(Copy, Clone)]
+pub enum MissingValueRange {
+    In { low: f64, high: f64 },
+    From { low: f64 },
+    To { high: f64 },
+}
+
+impl MissingValueRange {
+    pub fn new(low: f64, high: f64) -> Self {
+        const LOWEST: f64 = f64::MIN.next_up();
+        match (low, high) {
+            (f64::MIN | LOWEST, _) => Self::To { high },
+            (_, f64::MAX) => Self::From { low },
+            (_, _) => Self::In { low, high },
+        }
+    }
+
+    pub fn low(&self) -> Option<f64> {
+        match self {
+            MissingValueRange::In { low, .. } | MissingValueRange::From { low } => Some(*low),
+            MissingValueRange::To { .. } => None,
+        }
+    }
+
+    pub fn high(&self) -> Option<f64> {
+        match self {
+            MissingValueRange::In { high, .. } | MissingValueRange::To { high } => Some(*high),
+            MissingValueRange::From { .. } => None,
+        }
+    }
 }
 
 impl<S> Debug for MissingValues<S>
@@ -1218,22 +1240,9 @@ impl MissingValues {
                     .map(|v| Value::Number(endian.parse(v)))
                     .collect();
 
-                const LOWEST: f64 = f64::MIN.next_up();
-                let range =
-                    range.map(
-                        |(low, high)| match (endian.parse(low), endian.parse(high)) {
-                            (f64::MIN | LOWEST, high) => MissingValueRange::To {
-                                high: Value::Number(Some(high)),
-                            },
-                            (low, f64::MAX) => MissingValueRange::From {
-                                low: Value::Number(Some(low)),
-                            },
-                            (low, high) => MissingValueRange::In {
-                                low: Value::Number(Some(low)),
-                                high: Value::Number(Some(high)),
-                            },
-                        },
-                    );
+                let range = range.map(|(low, high)| {
+                    MissingValueRange::new(endian.parse(low), endian.parse(high))
+                });
                 return Ok(Self { values, range });
             }
             Ok(VarWidth::String(_)) if range.is_some() => warn(Warning::MissingValueStringRange),