Merge #173

173: common serde helpers for arrays r=Emilgardis a=burrbull Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>
rust-embedded · Nov 10, 2021 · 820c826 · 820c826
2 parents d40059c + 556faf5
commit 820c826
Show file tree

Hide file tree

Showing 7 changed files with 43 additions and 88 deletions.
diff --git a/svd-rs/CHANGELOG.md b/svd-rs/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Don't clone when serialize
 - Add optional entries to `Cpu`
 - `AddressBlock` now uses builder
 - Add `dim_name` and `dim_array_index` to `DimElement`

diff --git a/svd-rs/src/cluster.rs b/svd-rs/src/cluster.rs
@@ -45,31 +45,17 @@ impl Cluster {
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
+    use crate::{DeserArray, SerArray};
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    #[derive(serde::Deserialize, serde::Serialize)]
-    struct ClusterArray {
-        #[cfg_attr(
-            feature = "serde",
-            serde(flatten, default, skip_serializing_if = "Option::is_none")
-        )]
-        dim: Option<DimElement>,
-        #[cfg_attr(feature = "serde", serde(flatten))]
-        info: ClusterInfo,
-    }
-
     impl Serialize for Cluster {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: Serializer,
         {
             match self {
                 Self::Single(info) => info.serialize(serializer),
-                Self::Array(info, dim) => ClusterArray {
-                    dim: Some(dim.clone()),
-                    info: info.clone(),
-                }
-                .serialize(serializer),
+                Self::Array(info, dim) => SerArray { dim, info }.serialize(serializer),
             }
         }
     }
@@ -79,7 +65,7 @@ mod ser_de {
         where
             D: Deserializer<'de>,
         {
-            let ClusterArray { dim, info } = ClusterArray::deserialize(deserializer)?;
+            let DeserArray { dim, info } = DeserArray::<ClusterInfo>::deserialize(deserializer)?;
             if let Some(dim) = dim {
                 Ok(info.array(dim))
             } else {

diff --git a/svd-rs/src/derive_from.rs b/svd-rs/src/derive_from.rs
@@ -110,17 +110,15 @@ impl DeriveFrom for FieldInfo {
 impl DeriveFrom for Peripheral {
     fn derive_from(&self, other: &Self) -> Self {
         match (self, other) {
-            (Self::Single(info), Self::Single(other_info)) => {
-                Self::Single(info.derive_from(other_info))
-            }
+            (Self::Single(info), Self::Single(other_info)) => info.derive_from(other_info).single(),
             (Self::Single(info), Self::Array(other_info, other_dim)) => {
                 let mut dim = other_dim.clone();
                 dim.dim_name = None;
-                Self::Array(info.derive_from(other_info), dim)
+                info.derive_from(other_info).array(dim)
             }
             (Self::Array(info, dim), Self::Single(other_info))
             | (Self::Array(info, dim), Self::Array(other_info, _)) => {
-                Self::Array(info.derive_from(other_info), dim.clone())
+                info.derive_from(other_info).array(dim.clone())
             }
         }
     }
@@ -129,17 +127,15 @@ impl DeriveFrom for Peripheral {
 impl DeriveFrom for Cluster {
     fn derive_from(&self, other: &Self) -> Self {
         match (self, other) {
-            (Self::Single(info), Self::Single(other_info)) => {
-                Self::Single(info.derive_from(other_info))
-            }
+            (Self::Single(info), Self::Single(other_info)) => info.derive_from(other_info).single(),
             (Self::Single(info), Self::Array(other_info, other_dim)) => {
                 let mut dim = other_dim.clone();
                 dim.dim_name = None;
-                Self::Array(info.derive_from(other_info), dim)
+                info.derive_from(other_info).array(dim)
             }
             (Self::Array(info, dim), Self::Single(other_info))
             | (Self::Array(info, dim), Self::Array(other_info, _)) => {
-                Self::Array(info.derive_from(other_info), dim.clone())
+                info.derive_from(other_info).array(dim.clone())
             }
         }
     }
@@ -148,17 +144,15 @@ impl DeriveFrom for Cluster {
 impl DeriveFrom for Register {
     fn derive_from(&self, other: &Self) -> Self {
         match (self, other) {
-            (Self::Single(info), Self::Single(other_info)) => {
-                Self::Single(info.derive_from(other_info))
-            }
+            (Self::Single(info), Self::Single(other_info)) => info.derive_from(other_info).single(),
             (Self::Single(info), Self::Array(other_info, other_dim)) => {
                 let mut dim = other_dim.clone();
                 dim.dim_name = None;
-                Self::Array(info.derive_from(other_info), dim)
+                info.derive_from(other_info).array(dim)
             }
             (Self::Array(info, dim), Self::Single(other_info))
             | (Self::Array(info, dim), Self::Array(other_info, _)) => {
-                Self::Array(info.derive_from(other_info), dim.clone())
+                info.derive_from(other_info).array(dim.clone())
             }
         }
     }
@@ -167,17 +161,15 @@ impl DeriveFrom for Register {
 impl DeriveFrom for Field {
     fn derive_from(&self, other: &Self) -> Self {
         match (self, other) {
-            (Self::Single(info), Self::Single(other_info)) => {
-                Self::Single(info.derive_from(other_info))
-            }
+            (Self::Single(info), Self::Single(other_info)) => info.derive_from(other_info).single(),
             (Self::Single(info), Self::Array(other_info, other_dim)) => {
                 let mut dim = other_dim.clone();
                 dim.dim_name = None;
-                Self::Array(info.derive_from(other_info), dim)
+                info.derive_from(other_info).array(dim)
             }
             (Self::Array(info, dim), Self::Single(other_info))
             | (Self::Array(info, dim), Self::Array(other_info, _)) => {
-                Self::Array(info.derive_from(other_info), dim.clone())
+                info.derive_from(other_info).array(dim.clone())
             }
         }
     }

diff --git a/svd-rs/src/field.rs b/svd-rs/src/field.rs
@@ -44,31 +44,17 @@ impl Field {
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
+    use crate::{DeserArray, SerArray};
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    #[derive(serde::Deserialize, serde::Serialize)]
-    struct FieldArray {
-        #[cfg_attr(
-            feature = "serde",
-            serde(flatten, default, skip_serializing_if = "Option::is_none")
-        )]
-        dim: Option<DimElement>,
-        #[cfg_attr(feature = "serde", serde(flatten))]
-        info: FieldInfo,
-    }
-
     impl Serialize for Field {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: Serializer,
         {
             match self {
                 Self::Single(info) => info.serialize(serializer),
-                Self::Array(info, dim) => FieldArray {
-                    dim: Some(dim.clone()),
-                    info: info.clone(),
-                }
-                .serialize(serializer),
+                Self::Array(info, dim) => SerArray { dim, info }.serialize(serializer),
             }
         }
     }
@@ -78,7 +64,7 @@ mod ser_de {
         where
             D: Deserializer<'de>,
         {
-            let FieldArray { dim, info } = FieldArray::deserialize(deserializer)?;
+            let DeserArray { dim, info } = DeserArray::<FieldInfo>::deserialize(deserializer)?;
             if let Some(dim) = dim {
                 Ok(info.array(dim))
             } else {

diff --git a/svd-rs/src/lib.rs b/svd-rs/src/lib.rs
@@ -238,3 +238,21 @@ impl<T> EmptyToNone for Option<Vec<T>> {
         self.and_then(|v| if v.is_empty() { None } else { Some(v) })
     }
 }
+
+#[cfg(feature = "serde")]
+#[derive(serde::Serialize)]
+struct SerArray<'a, T> {
+    #[serde(flatten)]
+    dim: &'a DimElement,
+    #[serde(flatten)]
+    info: &'a T,
+}
+
+#[cfg(feature = "serde")]
+#[derive(serde::Deserialize)]
+struct DeserArray<T> {
+    #[serde(flatten, default)]
+    dim: Option<DimElement>,
+    #[serde(flatten)]
+    info: T,
+}
diff --git a/svd-rs/src/peripheral.rs b/svd-rs/src/peripheral.rs
@@ -45,31 +45,17 @@ impl Peripheral {
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
+    use crate::{DeserArray, SerArray};
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    #[derive(serde::Deserialize, serde::Serialize)]
-    struct PeripheralArray {
-        #[cfg_attr(
-            feature = "serde",
-            serde(flatten, default, skip_serializing_if = "Option::is_none")
-        )]
-        dim: Option<DimElement>,
-        #[cfg_attr(feature = "serde", serde(flatten))]
-        info: PeripheralInfo,
-    }
-
     impl Serialize for Peripheral {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: Serializer,
         {
             match self {
                 Self::Single(info) => info.serialize(serializer),
-                Self::Array(info, dim) => PeripheralArray {
-                    dim: Some(dim.clone()),
-                    info: info.clone(),
-                }
-                .serialize(serializer),
+                Self::Array(info, dim) => SerArray { dim, info }.serialize(serializer),
             }
         }
     }
@@ -79,7 +65,7 @@ mod ser_de {
         where
             D: Deserializer<'de>,
         {
-            let PeripheralArray { dim, info } = PeripheralArray::deserialize(deserializer)?;
+            let DeserArray { dim, info } = DeserArray::<PeripheralInfo>::deserialize(deserializer)?;
             if let Some(dim) = dim {
                 Ok(info.array(dim))
             } else {

diff --git a/svd-rs/src/register.rs b/svd-rs/src/register.rs
@@ -93,31 +93,17 @@ impl<'a> std::iter::Iterator for RegIterMut<'a> {
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
+    use crate::{DeserArray, SerArray};
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    #[derive(serde::Deserialize, serde::Serialize)]
-    struct RegisterArray {
-        #[cfg_attr(
-            feature = "serde",
-            serde(flatten, default, skip_serializing_if = "Option::is_none")
-        )]
-        dim: Option<DimElement>,
-        #[cfg_attr(feature = "serde", serde(flatten))]
-        info: RegisterInfo,
-    }
-
     impl Serialize for Register {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: Serializer,
         {
             match self {
                 Self::Single(info) => info.serialize(serializer),
-                Self::Array(info, dim) => RegisterArray {
-                    dim: Some(dim.clone()),
-                    info: info.clone(),
-                }
-                .serialize(serializer),
+                Self::Array(info, dim) => SerArray { dim, info }.serialize(serializer),
             }
         }
     }
@@ -127,7 +113,7 @@ mod ser_de {
         where
             D: Deserializer<'de>,
         {
-            let RegisterArray { dim, info } = RegisterArray::deserialize(deserializer)?;
+            let DeserArray { dim, info } = DeserArray::<RegisterInfo>::deserialize(deserializer)?;
             if let Some(dim) = dim {
                 Ok(info.array(dim))
             } else {