Merge #189

189: rename SingleArray -> MaybeArray r=Emilgardis a=burrbull

cc `@Emilgardis` 
What you think about this?

Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

svd-parser/src/array.rs

@@ -1,7 +1,7 @@
 use super::*;
-use svd_rs::{DimElement, Name, SingleArray};
+use svd_rs::{DimElement, MaybeArray, Name};
 
-pub fn parse_array<T>(tag: &str, tree: &Node, config: &Config) -> Result<SingleArray<T>, SVDErrorAt>
+pub fn parse_array<T>(tag: &str, tree: &Node, config: &Config) -> Result<MaybeArray<T>, SVDErrorAt>
 where
     T: Parse<Object = T, Error = SVDErrorAt, Config = Config> + Name,
 {
@@ -23,8 +23,8 @@ where
                 .at(tree.id()));
             }
         }
-        Ok(SingleArray::Array(info, array_info))
+        Ok(MaybeArray::Array(info, array_info))
     } else {
-        Ok(SingleArray::Single(info))
+        Ok(MaybeArray::Single(info))
     }
 }

svd-rs/CHANGELOG.md

@@ -8,12 +8,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## Unreleased
 
 - skip serializing `values` in `EnumeratedValues` if empty
+- add `names` function for arrays
 - add missing fields in `Device`, require `version`, `description`, `address_unit_bits` and `width`,
   also `schema_version` is required, but skipped during (de)serialization
 - merge `register` with `registerinfo` modules same as other `info`s
 - camelCase for WriteConstraint serialization
 - `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
+- Use generic `MaybeArray` 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

svd-rs/src/array.rs

@@ -3,14 +3,14 @@ use core::ops::{Deref, DerefMut};
 
 /// A single SVD instance or array of instances
 #[derive(Clone, Debug, PartialEq)]
-pub enum SingleArray<T> {
+pub enum MaybeArray<T> {
     /// A single instance
     Single(T),
     /// An array of instances
     Array(T, DimElement),
 }
 
-impl<T> Deref for SingleArray<T> {
+impl<T> Deref for MaybeArray<T> {
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -21,7 +21,7 @@ impl<T> Deref for SingleArray<T> {
     }
 }
 
-impl<T> DerefMut for SingleArray<T> {
+impl<T> DerefMut for MaybeArray<T> {
     fn deref_mut(&mut self) -> &mut T {
         match self {
             Self::Single(info) => info,
@@ -30,7 +30,7 @@ impl<T> DerefMut for SingleArray<T> {
     }
 }
 
-impl<T> SingleArray<T> {
+impl<T> MaybeArray<T> {
     /// Return `true` if instance is single
     pub const fn is_single(&self) -> bool {
         matches!(self, Self::Single(_))
@@ -41,7 +41,7 @@ impl<T> SingleArray<T> {
     }
 }
 
-impl<T> Name for SingleArray<T>
+impl<T> Name for MaybeArray<T>
 where
     T: Name,
 {
@@ -50,6 +50,13 @@ where
     }
 }
 
+/// Return list of names of instances in array
+pub fn names<'a, T: Name>(info: &'a T, dim: &'a DimElement) -> impl Iterator<Item = String> + 'a {
+    let name = info.name();
+    dim.indexes()
+        .map(move |i| name.replace("[%s]", &i).replace("%s", &i))
+}
+
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
@@ -71,7 +78,7 @@ mod ser_de {
         info: T,
     }
 
-    impl<T> Serialize for SingleArray<T>
+    impl<T> Serialize for MaybeArray<T>
     where
         T: Serialize,
     {
@@ -86,7 +93,7 @@ mod ser_de {
         }
     }
 
-    impl<'de, T> Deserialize<'de> for SingleArray<T>
+    impl<'de, T> Deserialize<'de> for MaybeArray<T>
     where
         T: Deserialize<'de>,
     {

svd-rs/src/cluster.rs

@@ -1,15 +1,14 @@
 use super::{
-    array::SingleArray,
     registercluster::{
         AllRegistersIter, AllRegistersIterMut, ClusterIter, ClusterIterMut, RegisterIter,
         RegisterIterMut,
     },
-    BuildError, DimElement, EmptyToNone, Name, Register, RegisterCluster, RegisterProperties,
-    SvdError, ValidateLevel,
+    BuildError, DimElement, EmptyToNone, MaybeArray, Name, Register, RegisterCluster,
+    RegisterProperties, SvdError, ValidateLevel,
 };
 
 /// Cluster describes a sequence of neighboring registers within a peripheral.
-pub type Cluster = SingleArray<ClusterInfo>;
+pub type Cluster = MaybeArray<ClusterInfo>;
 
 /// Errors from [`ClusterInfo::validate`]
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]

svd-rs/src/derive_from.rs

@@ -1,7 +1,7 @@
 //! Implementations of DeriveFrom, setting non-explicit fields.
 use crate::{
-    ClusterInfo, EnumeratedValues, FieldInfo, PeripheralInfo, RegisterInfo, RegisterProperties,
-    SingleArray,
+    ClusterInfo, EnumeratedValues, FieldInfo, MaybeArray, PeripheralInfo, RegisterInfo,
+    RegisterProperties,
 };
 
 /// Fill empty fields of structure with values of other structure
@@ -107,7 +107,7 @@ impl DeriveFrom for FieldInfo {
     }
 }
 
-impl<T> DeriveFrom for SingleArray<T>
+impl<T> DeriveFrom for MaybeArray<T>
 where
     T: DeriveFrom,
 {

svd-rs/src/field.rs

@@ -1,11 +1,10 @@
 use super::{
-    array::SingleArray, bitrange, Access, BitRange, BuildError, DimElement, EmptyToNone,
-    EnumeratedValues, ModifiedWriteValues, Name, ReadAction, SvdError, Usage, ValidateLevel,
-    WriteConstraint,
+    bitrange, Access, BitRange, BuildError, DimElement, EmptyToNone, EnumeratedValues, MaybeArray,
+    ModifiedWriteValues, Name, ReadAction, SvdError, Usage, ValidateLevel, WriteConstraint,
 };
 
 /// Describes a field or fields of a [register](crate::RegisterInfo).
-pub type Field = SingleArray<FieldInfo>;
+pub type Field = MaybeArray<FieldInfo>;
 
 /// Errors for [`FieldInfo::validate`]
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]

svd-rs/src/lib.rs

@@ -2,8 +2,9 @@
 //! SVD objects.
 //! This module defines components of an SVD along with parse and encode implementations
 
-mod array;
-pub use array::SingleArray;
+/// Common things for structures which can be collected in arrays
+pub mod array;
+pub use array::MaybeArray;
 
 /// Endian objects
 pub mod endian;

svd-rs/src/peripheral.rs

@@ -1,15 +1,14 @@
 use super::{
-    array::SingleArray,
     registercluster::{
         AllRegistersIter, AllRegistersIterMut, ClusterIter, ClusterIterMut, RegisterIter,
         RegisterIterMut,
     },
-    AddressBlock, BuildError, Cluster, DimElement, EmptyToNone, Interrupt, Name, Register,
-    RegisterCluster, RegisterProperties, SvdError, ValidateLevel,
+    AddressBlock, BuildError, Cluster, DimElement, EmptyToNone, Interrupt, MaybeArray, Name,
+    Register, RegisterCluster, RegisterProperties, SvdError, ValidateLevel,
 };
 
 /// A single peripheral or array of peripherals
-pub type Peripheral = SingleArray<PeripheralInfo>;
+pub type Peripheral = MaybeArray<PeripheralInfo>;
 
 /// Errors from [Peripheral::validate]
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]

svd-rs/src/register.rs

@@ -1,10 +1,10 @@
 use super::{
-    array::SingleArray, Access, BuildError, DimElement, EmptyToNone, Field, ModifiedWriteValues,
-    Name, ReadAction, RegisterProperties, SvdError, ValidateLevel, WriteConstraint,
+    Access, BuildError, DimElement, EmptyToNone, Field, MaybeArray, ModifiedWriteValues, Name,
+    ReadAction, RegisterProperties, SvdError, ValidateLevel, WriteConstraint,
 };
 
 /// A single register or array of registers. A register is a named, programmable resource that belongs to a [peripheral](crate::Peripheral).
-pub type Register = SingleArray<RegisterInfo>;
+pub type Register = MaybeArray<RegisterInfo>;
 
 /// Errors from [`RegisterInfo::validate`]
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]