common serde helpers for arrays

rust-embedded · Nov 10, 2021 · 556faf5 · 556faf5
1 parent b6ed0c0
commit 556faf5
Show file tree

Hide file tree

Showing 6 changed files with 31 additions and 68 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/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 {