Merge #181

181: use generic enum for arrays, remove OptIter, add more methods r=Emilgardis a=burrbull



Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>

Author: bors[bot]

svd-parser/src/array.rs

@@ -0,0 +1,30 @@
+use super::*;
+use svd_rs::{DimElement, Name, SingleArray};
+
+pub fn parse_array<T>(tag: &str, tree: &Node, config: &Config) -> Result<SingleArray<T>, SVDErrorAt>
+where
+    T: Parse<Object = T, Error = SVDErrorAt, Config = Config> + Name,
+{
+    if !tree.has_tag_name(tag) {
+        return Err(SVDError::NotExpectedTag(tag.into()).at(tree.id()));
+    }
+
+    let info = T::parse(tree, config)?;
+
+    if tree.get_child("dimIncrement").is_some() {
+        let array_info = DimElement::parse(tree, config)?;
+        check_has_placeholder(info.name(), tag).map_err(|e| e.at(tree.id()))?;
+        if let Some(indexes) = &array_info.dim_index {
+            if array_info.dim as usize != indexes.len() {
+                return Err(SVDError::IncorrectDimIndexesCount(
+                    array_info.dim as usize,
+                    indexes.len(),
+                )
+                .at(tree.id()));
+            }
+        }
+        Ok(SingleArray::Array(info, array_info))
+    } else {
+        Ok(SingleArray::Single(info))
+    }
+}

svd-parser/src/cluster.rs

@@ -1,33 +1,12 @@
 use super::*;
-use crate::svd::{Cluster, ClusterInfo, DimElement};
+use crate::svd::Cluster;
 
 impl Parse for Cluster {
     type Object = Self;
     type Error = SVDErrorAt;
     type Config = Config;
 
     fn parse(tree: &Node, config: &Self::Config) -> Result<Self, Self::Error> {
-        if !tree.has_tag_name("cluster") {
-            return Err(SVDError::NotExpectedTag("cluster".to_string()).at(tree.id()));
-        }
-
-        let info = ClusterInfo::parse(tree, config)?;
-
-        if tree.get_child("dimIncrement").is_some() {
-            let array_info = DimElement::parse(tree, config)?;
-            check_has_placeholder(&info.name, "cluster").map_err(|e| e.at(tree.id()))?;
-            if let Some(indexes) = &array_info.dim_index {
-                if array_info.dim as usize != indexes.len() {
-                    return Err(SVDError::IncorrectDimIndexesCount(
-                        array_info.dim as usize,
-                        indexes.len(),
-                    )
-                    .at(tree.id()));
-                }
-            }
-            Ok(info.array(array_info))
-        } else {
-            Ok(info.single())
-        }
+        parse_array("cluster", tree, config)
     }
 }

svd-parser/src/field.rs

@@ -1,34 +1,12 @@
 use super::*;
-use crate::svd::{DimElement, Field, FieldInfo};
-use crate::{elementext::ElementExt, Config};
+use crate::svd::Field;
 
 impl Parse for Field {
     type Object = Self;
     type Error = SVDErrorAt;
     type Config = Config;
 
     fn parse(tree: &Node, config: &Self::Config) -> Result<Self, Self::Error> {
-        if !tree.has_tag_name("field") {
-            return Err(SVDError::NotExpectedTag("field".to_string()).at(tree.id()));
-        }
-
-        let info = FieldInfo::parse(tree, config)?;
-
-        if tree.get_child("dimIncrement").is_some() {
-            let array_info = DimElement::parse(tree, config)?;
-            check_has_placeholder(&info.name, "field").map_err(|e| e.at(tree.id()))?;
-            if let Some(indexes) = &array_info.dim_index {
-                if array_info.dim as usize != indexes.len() {
-                    return Err(SVDError::IncorrectDimIndexesCount(
-                        array_info.dim as usize,
-                        indexes.len(),
-                    )
-                    .at(tree.id()));
-                }
-            }
-            Ok(info.array(array_info))
-        } else {
-            Ok(info.single())
-        }
+        parse_array("field", tree, config)
     }
 }

svd-parser/src/lib.rs

@@ -146,6 +146,9 @@ fn trim_utf8_bom(s: &str) -> &str {
     }
 }
 
+mod array;
+use array::parse_array;
+
 mod access;
 mod addressblock;
 mod bitrange;

svd-parser/src/peripheral.rs

@@ -1,34 +1,12 @@
 use super::*;
-use crate::elementext::ElementExt;
-use crate::svd::{DimElement, Peripheral, PeripheralInfo};
+use crate::svd::Peripheral;
 
 impl Parse for Peripheral {
     type Object = Self;
     type Error = SVDErrorAt;
     type Config = Config;
 
     fn parse(tree: &Node, config: &Self::Config) -> Result<Self, Self::Error> {
-        if !tree.has_tag_name("peripheral") {
-            return Err(SVDError::NotExpectedTag("peripheral".to_string()).at(tree.id()));
-        }
-
-        let info = PeripheralInfo::parse(tree, config)?;
-
-        if tree.get_child("dimIncrement").is_some() {
-            let array_info = DimElement::parse(tree, config)?;
-            check_has_placeholder(&info.name, "peripheral").map_err(|e| e.at(tree.id()))?;
-            if let Some(indexes) = &array_info.dim_index {
-                if array_info.dim as usize != indexes.len() {
-                    return Err(SVDError::IncorrectDimIndexesCount(
-                        array_info.dim as usize,
-                        indexes.len(),
-                    )
-                    .at(tree.id()));
-                }
-            }
-            Ok(info.array(array_info))
-        } else {
-            Ok(info.single())
-        }
+        parse_array("peripheral", tree, config)
     }
 }

svd-parser/src/register.rs

@@ -1,34 +1,12 @@
 use super::*;
-use crate::elementext::ElementExt;
-use crate::svd::{DimElement, Register, RegisterInfo};
+use crate::svd::Register;
 
 impl Parse for Register {
     type Object = Self;
     type Error = SVDErrorAt;
     type Config = Config;
 
     fn parse(tree: &Node, config: &Self::Config) -> Result<Self, Self::Error> {
-        if !tree.has_tag_name("register") {
-            return Err(SVDError::NotExpectedTag("register".to_string()).at(tree.id()));
-        }
-
-        let info = RegisterInfo::parse(tree, config)?;
-
-        if tree.get_child("dimIncrement").is_some() {
-            let array_info = DimElement::parse(tree, config)?;
-            check_has_placeholder(&info.name, "register").map_err(|e| e.at(tree.id()))?;
-            if let Some(indexes) = &array_info.dim_index {
-                if array_info.dim as usize != indexes.len() {
-                    return Err(SVDError::IncorrectDimIndexesCount(
-                        array_info.dim as usize,
-                        indexes.len(),
-                    )
-                    .at(tree.id()));
-                }
-            }
-            Ok(info.array(array_info))
-        } else {
-            Ok(info.single())
-        }
+        parse_array("register", tree, config)
     }
 }

svd-rs/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- `EnumeratedValues.usage()` now return `None` if it is derived, fix bug in usage check
+- Use generic `SingleArray` enum for types which can be either collected into SVD arrays or have only one instance
+- `Name` trait for structures that has `name` field
+- improves in iterators
+- `get_enumerated_values` by usage
+
 ## [v0.12.1] - 2021-12-08
 
 - Rename `reg_iter` to `all_registers`,

svd-rs/src/array.rs

@@ -0,0 +1,105 @@
+use super::{DimElement, Name};
+use core::ops::{Deref, DerefMut};
+
+/// A single SVD instance or array of instances
+#[derive(Clone, Debug, PartialEq)]
+pub enum SingleArray<T> {
+    /// A single instance
+    Single(T),
+    /// An array of instances
+    Array(T, DimElement),
+}
+
+impl<T> Deref for SingleArray<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        match self {
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
+        }
+    }
+}
+
+impl<T> DerefMut for SingleArray<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        match self {
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
+        }
+    }
+}
+
+impl<T> SingleArray<T> {
+    /// Return `true` if instance is single
+    pub const fn is_single(&self) -> bool {
+        matches!(self, Self::Single(_))
+    }
+    /// Return `true` if it is an array
+    pub const fn is_array(&self) -> bool {
+        matches!(self, Self::Array(_, _))
+    }
+}
+
+impl<T> Name for SingleArray<T>
+where
+    T: Name,
+{
+    fn name(&self) -> &str {
+        T::name(self)
+    }
+}
+
+#[cfg(feature = "serde")]
+mod ser_de {
+    use super::*;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    #[derive(serde::Serialize)]
+    struct SerArray<'a, T> {
+        #[serde(flatten)]
+        dim: &'a DimElement,
+        #[serde(flatten)]
+        info: &'a T,
+    }
+
+    #[derive(serde::Deserialize)]
+    struct DeserArray<T> {
+        #[serde(flatten, default)]
+        dim: Option<DimElement>,
+        #[serde(flatten)]
+        info: T,
+    }
+
+    impl<T> Serialize for SingleArray<T>
+    where
+        T: Serialize,
+    {
+        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) => SerArray::<T> { dim, info }.serialize(serializer),
+            }
+        }
+    }
+
+    impl<'de, T> Deserialize<'de> for SingleArray<T>
+    where
+        T: Deserialize<'de>,
+    {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            let DeserArray { dim, info } = DeserArray::<T>::deserialize(deserializer)?;
+            if let Some(dim) = dim {
+                Ok(Self::Array(info, dim))
+            } else {
+                Ok(Self::Single(info))
+            }
+        }
+    }
+}

svd-rs/src/cluster.rs

@@ -1,76 +1,4 @@
-use core::ops::{Deref, DerefMut};
-
-use super::{ClusterInfo, DimElement};
+use super::{array::SingleArray, ClusterInfo};
 
 /// Cluster describes a sequence of neighboring registers within a peripheral.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Cluster {
-    /// A single cluster, without any dimension.
-    Single(ClusterInfo),
-    /// A cluster array
-    Array(ClusterInfo, DimElement),
-}
-
-impl Deref for Cluster {
-    type Target = ClusterInfo;
-
-    fn deref(&self) -> &ClusterInfo {
-        match self {
-            Self::Single(info) => info,
-            Self::Array(info, _) => info,
-        }
-    }
-}
-
-impl DerefMut for Cluster {
-    fn deref_mut(&mut self) -> &mut ClusterInfo {
-        match self {
-            Self::Single(info) => info,
-            Self::Array(info, _) => info,
-        }
-    }
-}
-
-impl Cluster {
-    /// Return `true` if cluster instance is single
-    pub const fn is_single(&self) -> bool {
-        matches!(self, Self::Single(_))
-    }
-    /// Return `true` if it is cluster array
-    pub const fn is_array(&self) -> bool {
-        matches!(self, Self::Array(_, _))
-    }
-}
-
-#[cfg(feature = "serde")]
-mod ser_de {
-    use super::*;
-    use crate::{DeserArray, SerArray};
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-    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) => SerArray { dim, info }.serialize(serializer),
-            }
-        }
-    }
-
-    impl<'de> Deserialize<'de> for Cluster {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            let DeserArray { dim, info } = DeserArray::<ClusterInfo>::deserialize(deserializer)?;
-            if let Some(dim) = dim {
-                Ok(info.array(dim))
-            } else {
-                Ok(info.single())
-            }
-        }
-    }
-}
+pub type Cluster = SingleArray<ClusterInfo>;