cleanup

diff --git a/rust/pspp/src/spv/read/legacy_xml.rs b/rust/pspp/src/spv/read/legacy_xml.rs
index 90c3088347b96f0ecd4d573f356a93a9498905a7..707d39fa0876fe9c6e02cd7aea358a390426a43a 100644 (file)
--- a/rust/pspp/src/spv/read/legacy_xml.rs
+++ b/rust/pspp/src/spv/read/legacy_xml.rs
@@ -106,48 +106,11 @@ impl Map {
         map
     }
 
-    fn remap_formats(
-        &mut self,
-        format: &Option<Format>,
-        string_format: &Option<StringFormat>,
-    ) -> crate::format::Format {
-        let (format, relabels, try_strings_as_numbers) = if let Some(format) = &format {
-            (
-                Some(format.decode()),
-                format.relabels.as_slice(),
-                format.try_strings_as_numbers,
-            )
-        } else if let Some(string_format) = &string_format {
-            (None, string_format.relabels.as_slice(), false)
-        } else {
-            (None, [].as_slice(), false)
-        };
-        for relabel in relabels {
-            let value = if try_strings_as_numbers && let Ok(to) = relabel.to.trim().parse::<f64>() {
-                Datum::Number(Some(to))
-            } else if let Some(format) = format
-                && let Ok(to) = relabel.to.trim().parse::<f64>()
-            {
-                Datum::String(
-                    Datum::<String>::Number(Some(to))
-                        .display(format)
-                        .with_stretch()
-                        .to_string(),
-                )
-            } else {
-                Datum::String(relabel.to.clone())
-            };
-            self.0.insert(OrderedFloat(relabel.from), value);
-        }
-        format.unwrap_or(F8_0)
-    }
-
     fn apply(&self, data: &mut Vec<DataValue>) {
         for value in data {
-            let Datum::Number(Some(number)) = value.value else {
-                continue;
-            };
-            if let Some(to) = self.0.get(&OrderedFloat(number)) {
+            if let Datum::Number(Some(number)) = value.value
+                && let Some(to) = self.0.get(&OrderedFloat(number))
+            {
                 value.index = Some(number);
                 value.value = to.clone();
             }
@@ -187,16 +150,6 @@ impl Map {
         }
         map
     }
-
-    fn lookup<'a>(&'a self, dv: &'a DataValue) -> &'a Datum<String> {
-        if let Datum::Number(Some(number)) = &dv.value
-            && let Some(value) = self.0.get(&OrderedFloat(*number))
-        {
-            value
-        } else {
-            &dv.value
-        }
-    }
 }
 
 /// A warning decoding a legacy XML member.
@@ -771,7 +724,6 @@ pub struct Series {
     pub name: String,
     label: Option<String>,
     pub values: Vec<DataValue>,
-    map: Map,
     affixes: Vec<Affix>,
     coordinate_to_index: RefCell<BTreeMap<usize, CategoryLocator>>,
     dimension_index: Cell<Option<usize>>,
@@ -786,12 +738,11 @@ impl Debug for Series {
 }
 
 impl Series {
-    fn new(name: String, values: Vec<DataValue>, map: Map) -> Self {
+    fn new(name: String, values: Vec<DataValue>) -> Self {
         Self {
             name,
             label: None,
             values,
-            map,
             affixes: Vec::new(),
             coordinate_to_index: Default::default(),
             dimension_index: Default::default(),
@@ -805,7 +756,7 @@ impl Series {
     }
 
     fn new_name(&self, dv: &DataValue, footnotes: &pivot::Footnotes) -> Value {
-        let mut name = Value::new_datum(self.map.lookup(dv));
+        let mut name = Value::new_datum(&dv.value);
         for affix in &self.affixes {
             if let Some(index) = affix.defines_reference.checked_sub(1)
                 && let Ok(index) = usize::try_from(index)
@@ -905,17 +856,18 @@ impl SourceVariable {
         } else if let Some(string_format) = &self.string_format {
             Map::from_string_format(string_format).apply(&mut data);
         };
-        let mut map = Map::new();
         if let Some(label_series) = label_series {
+            let mut map = Map::new();
             map.insert_labels(
                 &data,
                 label_series,
                 self.format.as_ref().map_or(F8_0, |f| f.decode()),
             );
+            map.apply(&mut data);
         }
         series.insert(
             &self.id,
-            Series::new(self.id.clone(), data, map)
+            Series::new(self.id.clone(), data)
                 .with_affixes(Vec::from(self.affixes()))
                 .with_label(self.label.clone()),
         );
@@ -996,7 +948,7 @@ impl DerivedVariable {
         } else if let Some(string_format) = &self.string_format {
             Map::from_string_format(string_format).apply(&mut values);
         };
-        series.insert(&self.id, Series::new(self.id.clone(), values, Map::new()));
+        series.insert(&self.id, Series::new(self.id.clone(), values));
         true
     }
 }
@@ -2221,7 +2173,7 @@ fn decode_dimension<'a>(
         for end in 1..=cats.len() {
             let dv1 = &variable.values[cats[start].index];
             if end >= cats.len() || &variable.values[cats[end].index].value != &dv1.value {
-                if !variable.map.lookup(dv1).is_spaces() {
+                if !dv1.value.is_spaces() {
                     let name = variable.new_name(dv1, footnotes);
                     let next_cat = CatBuilder {
                         category: Group::new(name)