cleanup

diff --git a/rust/pspp/src/spv/read/legacy_xml.rs b/rust/pspp/src/spv/read/legacy_xml.rs
index bf3d64903d2fec2de7e17eb44c4241a60a4f1213..8b49cf98829d9e6abec9b77aa185b14d06f88f31 100644 (file)
--- a/rust/pspp/src/spv/read/legacy_xml.rs
+++ b/rust/pspp/src/spv/read/legacy_xml.rs
@@ -109,36 +109,6 @@ impl Map {
         Self::default()
     }
 
-    fn from_format(format: &Format) -> Self {
-        let f = format.decode();
-        let mut map = Self::new();
-        for relabel in &format.relabels {
-            let value = match relabel.to.trim().parse::<f64>().ok() {
-                Some(to) if format.try_strings_as_numbers => Datum::Number(Some(to)),
-                Some(to) => Datum::String(
-                    Datum::<String>::Number(Some(to))
-                        .display(f)
-                        .with_stretch()
-                        .to_string(),
-                ),
-                None => Datum::String(relabel.to.clone()),
-            };
-            map.0.insert(OrderedFloat(relabel.from), value);
-        }
-        map
-    }
-
-    fn from_string_format(string_format: &StringFormat) -> Self {
-        let mut map = Self::new();
-        for relabel in &string_format.relabels {
-            map.0.insert(
-                OrderedFloat(relabel.from),
-                Datum::String(relabel.to.clone()),
-            );
-        }
-        map
-    }
-
     fn apply(&self, data: &mut Vec<Datum<String>>) {
         for value in data {
             if let Datum::Number(Some(number)) = value
@@ -884,9 +854,9 @@ impl Variable for SourceVariable {
             (Vec::new(), Vec::new())
         };
         if let Some(format) = &self.format {
-            Map::from_format(format).apply(&mut data);
+            format.mapping().apply(&mut data);
         } else if let Some(string_format) = &self.string_format {
-            Map::from_string_format(string_format).apply(&mut data);
+            string_format.mapping().apply(&mut data);
         };
         if let Some(label_series) = label_series {
             let format = self.format.as_ref().map_or(F8_0, |f| f.decode());
@@ -980,9 +950,9 @@ impl Variable for DerivedVariable {
         };
         Map::from_vmes(&self.value_map).apply(&mut values);
         if let Some(format) = &self.format {
-            Map::from_format(format).apply(&mut values);
+            format.mapping().apply(&mut values);
         } else if let Some(string_format) = &self.string_format {
-            Map::from_string_format(string_format).apply(&mut values);
+            string_format.mapping().apply(&mut values);
         };
         series.insert(
             &self.id,
@@ -1015,6 +985,21 @@ struct StringFormat {
     affixes: Vec<Affix>,
 }
 
+impl StringFormat {
+    fn mapping(&self) -> Map {
+        Map(self
+            .relabels
+            .iter()
+            .map(|relabel| {
+                (
+                    OrderedFloat(relabel.from),
+                    Datum::String(relabel.to.clone()),
+                )
+            })
+            .collect())
+    }
+}
+
 #[derive(Deserialize, Debug, Default)]
 #[serde(rename_all = "camelCase")]
 struct Format {
@@ -1057,6 +1042,27 @@ struct Format {
 }
 
 impl Format {
+    fn mapping(&self) -> Map {
+        let format = self.decode();
+        Map(self
+            .relabels
+            .iter()
+            .map(|relabel| {
+                let value = match relabel.to.trim().parse::<f64>().ok() {
+                    Some(to) if self.try_strings_as_numbers => Datum::Number(Some(to)),
+                    Some(to) => Datum::String(
+                        Datum::<String>::Number(Some(to))
+                            .display(format)
+                            .with_stretch()
+                            .to_string(),
+                    ),
+                    None => Datum::String(relabel.to.clone()),
+                };
+                (OrderedFloat(relabel.from), value)
+            })
+            .collect())
+    }
+
     fn decode(&self) -> crate::format::Format {
         if self.base_format.is_some() {
             SignificantDateTimeFormat::from(self).decode()