From e84a39b7c46324d3c1246ffc3e5e13fbab67d473 Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Mon, 7 Aug 2023 14:16:44 +0200 Subject: [PATCH] Apply exported sorting to items itself and nested items --- src/model/data_catalogue.rs | 33 +++++++++++ src/model/data_form.rs | 43 ++++++++++++++ src/model/mod.rs | 6 ++ src/model/onkostar_editor.rs | 18 +++++- src/model/property_catalogue.rs | 100 ++++++++++++++++++++++++++++++++ src/model/unterformular.rs | 43 ++++++++++++++ 6 files changed, 242 insertions(+), 1 deletion(-) diff --git a/src/model/data_catalogue.rs b/src/model/data_catalogue.rs index 02d3dd7..1c98b2b 100644 --- a/src/model/data_catalogue.rs +++ b/src/model/data_catalogue.rs @@ -70,6 +70,16 @@ impl Sortable for DataCatalogue { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + self.entries + .entry + .sort_unstable_by_key(|item| item.sorting_key()); + self.entries.entry.iter_mut().for_each(|item| { + item.sorted(); + }); + self + } } impl Comparable for DataCatalogue { @@ -151,6 +161,23 @@ pub struct Entry { revision: u16, } +impl Sortable for Entry { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut use_) = self.use_ { + use_.program_module + .sort_unstable_by_key(|item| item.sorting_key()) + } + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct Use { @@ -166,3 +193,9 @@ pub struct ProgramModule { #[serde(rename = "@name")] name: String, } + +impl Sortable for ProgramModule { + fn sorting_key(&self) -> String { + format!("{}-{}", self.program, self.name) + } +} diff --git a/src/model/data_form.rs b/src/model/data_form.rs index eff5eab..b545258 100644 --- a/src/model/data_form.rs +++ b/src/model/data_form.rs @@ -192,6 +192,29 @@ impl Sortable for DataForm { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + self.data_catalogues.data_catalogue.sort_unstable(); + + self.entries + .entry + .sort_unstable_by_key(|item| item.sorting_key()); + + self.entries.entry.iter_mut().for_each(|item| { + item.sorted(); + }); + + if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule { + plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone()); + + plausibility_rule.iter_mut().for_each(|item| { + if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name { + data_form_entry_names.sort_unstable(); + } + }); + } + self + } } impl Comparable for DataForm { @@ -433,6 +456,26 @@ impl FormEntry for Entry { } } +impl Sortable for Entry { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut filter) = self.filter { + if let Some(ref mut ref_entries) = filter.ref_entries { + if let Some(ref mut ref_entry) = ref_entries.ref_entry { + ref_entry.sort_unstable() + } + } + } + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct DataFormEntries { diff --git a/src/model/mod.rs b/src/model/mod.rs index 67783d2..bb20d0d 100644 --- a/src/model/mod.rs +++ b/src/model/mod.rs @@ -239,6 +239,12 @@ pub trait Listable { pub trait Sortable { fn sorting_key(&self) -> String; + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + self + } } pub trait Comparable: Debug { diff --git a/src/model/onkostar_editor.rs b/src/model/onkostar_editor.rs index 1ec3307..914856a 100644 --- a/src/model/onkostar_editor.rs +++ b/src/model/onkostar_editor.rs @@ -79,17 +79,33 @@ impl OnkostarEditor { .property_catalogue .sort_unstable_by_key(|e| e.sorting_key()); + self.editor.property_catalogue.iter_mut().for_each(|item| { + item.sorted(); + }); + self.editor .data_catalogue .sort_unstable_by_key(|e| e.sorting_key()); + self.editor.data_catalogue.iter_mut().for_each(|item| { + item.sorted(); + }); + self.editor .data_form .sort_unstable_by_key(|e| e.sorting_key()); + self.editor.data_form.iter_mut().for_each(|item| { + item.sorted(); + }); + self.editor .unterformular .sort_unstable_by_key(|e| e.sorting_key()); + + self.editor.unterformular.iter_mut().for_each(|item| { + item.sorted(); + }); } pub fn print_diff(&mut self, other: &mut Self, strict: bool) { @@ -182,7 +198,7 @@ impl OnkostarEditor { _ => { if strict && entry_a.get_hash() != entry_b.get_hash() { println!( - "{}: {} (z.B. Reihenfolge von Unterelementen)", + "{}: {} (z.B. GUID oder Reihenfolge von Unterelementen)", entry_a.get_name(), style("Inhaltlich verschieden").yellow() ); diff --git a/src/model/property_catalogue.rs b/src/model/property_catalogue.rs index 72f8256..3d59850 100644 --- a/src/model/property_catalogue.rs +++ b/src/model/property_catalogue.rs @@ -67,6 +67,16 @@ impl Sortable for PropertyCatalogue { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + if let Some(ref mut versions) = self.versions.entry { + versions.sort_unstable_by_key(|item| item.version_number); + versions.iter_mut().for_each(|version| { + version.sorted(); + }); + } + self + } } impl Comparable for PropertyCatalogue { @@ -115,6 +125,40 @@ pub struct Version { categories: Categories, } +impl Sortable for Version { + fn sorting_key(&self) -> String { + self.oid.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut abbildung) = self.abbildung { + abbildung.sort_unstable_by_key(|item| item.sorting_key()); + abbildung.iter_mut().for_each(|item| { + item.sorted(); + }); + } + + self.entries + .content + .sort_unstable_by_key(|item| item.sorting_key()); + self.entries.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self.categories + .content + .sort_unstable_by_key(|item| item.sorting_key()); + self.categories.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct VersionEntries { @@ -141,6 +185,12 @@ pub struct VersionEntry { position: String, } +impl Sortable for VersionEntry { + fn sorting_key(&self) -> String { + self.code.clone() + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct Categories { @@ -165,6 +215,26 @@ pub struct Category { category_entries: CategoryEntries, } +impl Sortable for Category { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + self.category_entries + .content + .sort_unstable_by_key(|item| item.sorting_key()); + self.category_entries.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct CategoryEntries { @@ -191,6 +261,12 @@ pub struct CategoryEntry { note: Option, } +impl Sortable for CategoryEntry { + fn sorting_key(&self) -> String { + self.code.clone() + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct Abbildung { @@ -200,6 +276,24 @@ pub struct Abbildung { content: Vec, } +impl Sortable for Abbildung { + fn sorting_key(&self) -> String { + self.ziel_mk_version_oid.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + self.content.sort_unstable_by_key(|item| item.sorting_key()); + self.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct AbbildungEintrag { @@ -209,6 +303,12 @@ pub struct AbbildungEintrag { entry_to: AbbildungEntry, } +impl Sortable for AbbildungEintrag { + fn sorting_key(&self) -> String { + format!("{}-{}", self.entry_from.code, self.entry_to.code) + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct AbbildungEntry { diff --git a/src/model/unterformular.rs b/src/model/unterformular.rs index 01a60c1..8d37472 100644 --- a/src/model/unterformular.rs +++ b/src/model/unterformular.rs @@ -211,6 +211,29 @@ impl Sortable for Unterformular { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + self.data_catalogues.data_catalogue.sort_unstable(); + + self.entries + .entry + .sort_unstable_by_key(|item| item.sorting_key()); + + self.entries.entry.iter_mut().for_each(|item| { + item.sorted(); + }); + + if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule { + plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone()); + + plausibility_rule.iter_mut().for_each(|item| { + if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name { + data_form_entry_names.sort_unstable(); + } + }); + } + self + } } impl Comparable for Unterformular { @@ -453,6 +476,26 @@ impl FormEntry for Entry { } } +impl Sortable for Entry { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut filter) = self.filter { + if let Some(ref mut ref_entries) = filter.ref_entries { + if let Some(ref mut ref_entry) = ref_entries.ref_entry { + ref_entry.sort_unstable() + } + } + } + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct DataFormEntries {