Merge #165

bors[bot] · burrbull · web-flow · commit 0044fb728037 · 2021-11-07T13:55:06.000Z
165: array constructors r=Emilgardis a=burrbull



Co-authored-by: Andrey Zgarbul &lt;zgarbul.andrey@gmail.com&gt;
diff --git a/svd-parser/src/cluster.rs b/svd-parser/src/cluster.rs
@@ -25,10 +25,9 @@ impl Parse for Cluster {
                     .at(tree.id()));
                 }
             }
-
-            Ok(Self::Array(info, array_info))
+            Ok(info.array(array_info))
         } else {
-            Ok(Self::Single(info))
+            Ok(info.single())
         }
     }
 }
diff --git a/svd-parser/src/field.rs b/svd-parser/src/field.rs
@@ -26,9 +26,9 @@ impl Parse for Field {
                     .at(tree.id()));
                 }
             }
-            Ok(Self::Array(info, array_info))
+            Ok(info.array(array_info))
         } else {
-            Ok(Self::Single(info))
+            Ok(info.single())
         }
     }
 }
diff --git a/svd-parser/src/peripheral.rs b/svd-parser/src/peripheral.rs
@@ -26,9 +26,9 @@ impl Parse for Peripheral {
                     .at(tree.id()));
                 }
             }
-            Ok(Self::Array(info, array_info))
+            Ok(info.array(array_info))
         } else {
-            Ok(Self::Single(info))
+            Ok(info.single())
         }
     }
 }
diff --git a/svd-parser/src/register.rs b/svd-parser/src/register.rs
@@ -26,9 +26,9 @@ impl Parse for Register {
                     .at(tree.id()));
                 }
             }
-            Ok(Self::Array(info, array_info))
+            Ok(info.array(array_info))
         } else {
-            Ok(Self::Single(info))
+            Ok(info.single())
         }
     }
 }
diff --git a/svd-rs/CHANGELOG.md b/svd-rs/CHANGELOG.md
@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add `single` and `array` for `Info` types, 
+  `is_single` and `is_array` for `Peripheral`, `Cluster`, `Register` and `Field`
 - Add array support for peripherals
 
 ## [v0.11.2] - 2021-11-04
diff --git a/svd-rs/src/cluster.rs b/svd-rs/src/cluster.rs
@@ -16,21 +16,32 @@ impl Deref for Cluster {
 
     fn deref(&self) -> &ClusterInfo {
         match self {
-            Cluster::Single(info) => info,
-            Cluster::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
 impl DerefMut for Cluster {
     fn deref_mut(&mut self) -> &mut ClusterInfo {
         match self {
-            Cluster::Single(info) => info,
-            Cluster::Array(info, _) => info,
+            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::*;
@@ -53,8 +64,8 @@ mod ser_de {
             S: Serializer,
         {
             match self {
-                Cluster::Single(info) => info.serialize(serializer),
-                Cluster::Array(info, dim) => ClusterArray {
+                Self::Single(info) => info.serialize(serializer),
+                Self::Array(info, dim) => ClusterArray {
                     dim: Some(dim.clone()),
                     info: info.clone(),
                 }
@@ -70,9 +81,9 @@ mod ser_de {
         {
             let ClusterArray { dim, info } = ClusterArray::deserialize(deserializer)?;
             if let Some(dim) = dim {
-                Ok(Cluster::Array(info, dim))
+                Ok(info.array(dim))
             } else {
-                Ok(Cluster::Single(info))
+                Ok(info.single())
             }
         }
     }
diff --git a/svd-rs/src/clusterinfo.rs b/svd-rs/src/clusterinfo.rs
@@ -1,6 +1,7 @@
 use super::{
     register::{RegIter, RegIterMut},
-    BuildError, EmptyToNone, RegisterCluster, RegisterProperties, SvdError, ValidateLevel,
+    BuildError, Cluster, DimElement, EmptyToNone, RegisterCluster, RegisterProperties, SvdError,
+    ValidateLevel,
 };
 
 /// Errors from [`ClusterInfo::validate`]
@@ -149,7 +150,14 @@ impl ClusterInfo {
     pub fn builder() -> ClusterInfoBuilder {
         ClusterInfoBuilder::default()
     }
-
+    /// Construct single [`Cluster`]
+    pub const fn single(self) -> Cluster {
+        Cluster::Single(self)
+    }
+    /// Construct [`Cluster`] array
+    pub const fn array(self, dim: DimElement) -> Cluster {
+        Cluster::Array(self, dim)
+    }
     /// Modify an existing [`ClusterInfo`] based on a [builder](ClusterInfoBuilder).
     pub fn modify_from(
         &mut self,
@@ -200,9 +208,7 @@ impl ClusterInfo {
         }
         Ok(())
     }
-}
 
-impl ClusterInfo {
     /// returns a iterator over all registers the cluster contains
     pub fn reg_iter(&self) -> RegIter {
         let mut rem: Vec<&RegisterCluster> = Vec::with_capacity(self.children.len());
diff --git a/svd-rs/src/field.rs b/svd-rs/src/field.rs
@@ -15,21 +15,32 @@ impl Deref for Field {
 
     fn deref(&self) -> &FieldInfo {
         match self {
-            Field::Single(info) => info,
-            Field::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
 impl DerefMut for Field {
     fn deref_mut(&mut self) -> &mut FieldInfo {
         match self {
-            Field::Single(info) => info,
-            Field::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
+impl Field {
+    /// Return `true` if field instance is single
+    pub const fn is_single(&self) -> bool {
+        matches!(self, Self::Single(_))
+    }
+    /// Return `true` if it is field array
+    pub const fn is_array(&self) -> bool {
+        matches!(self, Self::Array(_, _))
+    }
+}
+
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
@@ -52,8 +63,8 @@ mod ser_de {
             S: Serializer,
         {
             match self {
-                Field::Single(info) => info.serialize(serializer),
-                Field::Array(info, dim) => FieldArray {
+                Self::Single(info) => info.serialize(serializer),
+                Self::Array(info, dim) => FieldArray {
                     dim: Some(dim.clone()),
                     info: info.clone(),
                 }
@@ -69,9 +80,9 @@ mod ser_de {
         {
             let FieldArray { dim, info } = FieldArray::deserialize(deserializer)?;
             if let Some(dim) = dim {
-                Ok(Field::Array(info, dim))
+                Ok(info.array(dim))
             } else {
-                Ok(Field::Single(info))
+                Ok(info.single())
             }
         }
     }
diff --git a/svd-rs/src/fieldinfo.rs b/svd-rs/src/fieldinfo.rs
@@ -1,6 +1,6 @@
 use super::{
-    bitrange, Access, BitRange, BuildError, EmptyToNone, EnumeratedValues, ModifiedWriteValues,
-    SvdError, Usage, ValidateLevel, WriteConstraint,
+    bitrange, Access, BitRange, BuildError, DimElement, EmptyToNone, EnumeratedValues, Field,
+    ModifiedWriteValues, SvdError, Usage, ValidateLevel, WriteConstraint,
 };
 
 /// Errors for [`FieldInfo::validate`]
@@ -198,6 +198,14 @@ impl FieldInfo {
     pub fn builder() -> FieldInfoBuilder {
         FieldInfoBuilder::default()
     }
+    /// Construct single [`Field`]
+    pub const fn single(self) -> Field {
+        Field::Single(self)
+    }
+    /// Construct [`Field`] array
+    pub const fn array(self, dim: DimElement) -> Field {
+        Field::Array(self, dim)
+    }
     /// Modify an existing [`FieldInfo`] based on a [builder](FieldInfoBuilder).
     pub fn modify_from(
         &mut self,
diff --git a/svd-rs/src/peripheral.rs b/svd-rs/src/peripheral.rs
@@ -16,21 +16,32 @@ impl Deref for Peripheral {
 
     fn deref(&self) -> &PeripheralInfo {
         match self {
-            Peripheral::Single(info) => info,
-            Peripheral::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
 impl DerefMut for Peripheral {
     fn deref_mut(&mut self) -> &mut PeripheralInfo {
         match self {
-            Peripheral::Single(info) => info,
-            Peripheral::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
+impl Peripheral {
+    /// Return `true` if peripheral instance is single
+    pub const fn is_single(&self) -> bool {
+        matches!(self, Self::Single(_))
+    }
+    /// Return `true` if it is peripheral array
+    pub const fn is_array(&self) -> bool {
+        matches!(self, Self::Array(_, _))
+    }
+}
+
 #[cfg(feature = "serde")]
 mod ser_de {
     use super::*;
@@ -53,8 +64,8 @@ mod ser_de {
             S: Serializer,
         {
             match self {
-                Peripheral::Single(info) => info.serialize(serializer),
-                Peripheral::Array(info, dim) => PeripheralArray {
+                Self::Single(info) => info.serialize(serializer),
+                Self::Array(info, dim) => PeripheralArray {
                     dim: Some(dim.clone()),
                     info: info.clone(),
                 }
@@ -70,9 +81,9 @@ mod ser_de {
         {
             let PeripheralArray { dim, info } = PeripheralArray::deserialize(deserializer)?;
             if let Some(dim) = dim {
-                Ok(Peripheral::Array(info, dim))
+                Ok(info.array(dim))
             } else {
-                Ok(Peripheral::Single(info))
+                Ok(info.single())
             }
         }
     }
diff --git a/svd-rs/src/peripheralinfo.rs b/svd-rs/src/peripheralinfo.rs
@@ -1,7 +1,7 @@
 use super::{
     register::{RegIter, RegIterMut},
-    AddressBlock, BuildError, EmptyToNone, Interrupt, RegisterCluster, RegisterProperties,
-    SvdError, ValidateLevel,
+    AddressBlock, BuildError, DimElement, EmptyToNone, Interrupt, Peripheral, RegisterCluster,
+    RegisterProperties, SvdError, ValidateLevel,
 };
 
 /// Errors from [Peripheral::validate]
@@ -208,10 +208,18 @@ impl PeripheralInfoBuilder {
 }
 
 impl PeripheralInfo {
-    /// Make a builder for [`Peripheral`]
+    /// Make a builder for [`PeripheralInfo`]
     pub fn builder() -> PeripheralInfoBuilder {
         PeripheralInfoBuilder::default()
     }
+    /// Construct single [`Peripheral`]
+    pub const fn single(self) -> Peripheral {
+        Peripheral::Single(self)
+    }
+    /// Construct [`Peripheral`] array
+    pub const fn array(self, dim: DimElement) -> Peripheral {
+        Peripheral::Array(self, dim)
+    }
     /// Modify an existing [`Peripheral`] based on a [builder](PeripheralInfoBuilder).
     pub fn modify_from(
         &mut self,
diff --git a/svd-rs/src/register.rs b/svd-rs/src/register.rs
@@ -16,21 +16,32 @@ impl Deref for Register {
 
     fn deref(&self) -> &RegisterInfo {
         match self {
-            Register::Single(info) => info,
-            Register::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
 impl DerefMut for Register {
     fn deref_mut(&mut self) -> &mut RegisterInfo {
         match self {
-            Register::Single(info) => info,
-            Register::Array(info, _) => info,
+            Self::Single(info) => info,
+            Self::Array(info, _) => info,
         }
     }
 }
 
+impl Register {
+    /// Return `true` if register instance is single
+    pub const fn is_single(&self) -> bool {
+        matches!(self, Self::Single(_))
+    }
+    /// Return `true` if it is register array
+    pub const fn is_array(&self) -> bool {
+        matches!(self, Self::Array(_, _))
+    }
+}
+
 /// Register iterator
 pub struct RegIter<'a> {
     pub(crate) rem: Vec<&'a RegisterCluster>,
@@ -101,8 +112,8 @@ mod ser_de {
             S: Serializer,
         {
             match self {
-                Register::Single(info) => info.serialize(serializer),
-                Register::Array(info, dim) => RegisterArray {
+                Self::Single(info) => info.serialize(serializer),
+                Self::Array(info, dim) => RegisterArray {
                     dim: Some(dim.clone()),
                     info: info.clone(),
                 }
@@ -118,9 +129,9 @@ mod ser_de {
         {
             let RegisterArray { dim, info } = RegisterArray::deserialize(deserializer)?;
             if let Some(dim) = dim {
-                Ok(Register::Array(info, dim))
+                Ok(info.array(dim))
             } else {
-                Ok(Register::Single(info))
+                Ok(info.single())
             }
         }
     }
diff --git a/svd-rs/src/registerinfo.rs b/svd-rs/src/registerinfo.rs

Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,9 @@ impl Parse for Cluster {`
`25`	`25`	`.at(tree.id()));`
`26`	`26`	`}`
`27`	`27`	`}`
`28`		`-`
`29`		`- Ok(Self::Array(info, array_info))`
	`28`	`+ Ok(info.array(array_info))`
`30`	`29`	`} else {`
`31`		`- Ok(Self::Single(info))`
	`30`	`+ Ok(info.single())`
`32`	`31`	`}`
`33`	`32`	`}`
`34`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ impl Parse for Field {`
`26`	`26`	`.at(tree.id()));`
`27`	`27`	`}`
`28`	`28`	`}`
`29`		`- Ok(Self::Array(info, array_info))`
	`29`	`+ Ok(info.array(array_info))`
`30`	`30`	`} else {`
`31`		`- Ok(Self::Single(info))`
	`31`	`+ Ok(info.single())`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ impl Parse for Peripheral {`
`26`	`26`	`.at(tree.id()));`
`27`	`27`	`}`
`28`	`28`	`}`
`29`		`- Ok(Self::Array(info, array_info))`
	`29`	`+ Ok(info.array(array_info))`
`30`	`30`	`} else {`
`31`		`- Ok(Self::Single(info))`
	`31`	`+ Ok(info.single())`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ impl Parse for Register {`
`26`	`26`	`.at(tree.id()));`
`27`	`27`	`}`
`28`	`28`	`}`
`29`		`- Ok(Self::Array(info, array_info))`
	`29`	`+ Ok(info.array(array_info))`
`30`	`30`	`} else {`
`31`		`- Ok(Self::Single(info))`
	`31`	`+ Ok(info.single())`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,21 +16,32 @@ impl Deref for Cluster {`
`16`	`16`
`17`	`17`	`fn deref(&self) -> &ClusterInfo {`
`18`	`18`	`match self {`
`19`		`- Cluster::Single(info) => info,`
`20`		`- Cluster::Array(info, _) => info,`
	`19`	`+ Self::Single(info) => info,`
	`20`	`+ Self::Array(info, _) => info,`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`impl DerefMut for Cluster {`
`26`	`26`	`fn deref_mut(&mut self) -> &mut ClusterInfo {`
`27`	`27`	`match self {`
`28`		`- Cluster::Single(info) => info,`
`29`		`- Cluster::Array(info, _) => info,`
	`28`	`+ Self::Single(info) => info,`
	`29`	`+ Self::Array(info, _) => info,`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
	`34`	`+impl Cluster {`
	`35`	+ /// Return `true` if cluster instance is single
	`36`	`+ pub const fn is_single(&self) -> bool {`
	`37`	`+ matches!(self, Self::Single(_))`
	`38`	`+ }`
	`39`	+ /// Return `true` if it is cluster array
	`40`	`+ pub const fn is_array(&self) -> bool {`
	`41`	`+ matches!(self, Self::Array(_, _))`
	`42`	`+ }`
	`43`	`+}`
	`44`	`+`
`34`	`45`	`#[cfg(feature = "serde")]`
`35`	`46`	`mod ser_de {`
`36`	`47`	`use super::*;`
`@@ -53,8 +64,8 @@ mod ser_de {`
`53`	`64`	`S: Serializer,`
`54`	`65`	`{`
`55`	`66`	`match self {`
`56`		`- Cluster::Single(info) => info.serialize(serializer),`
`57`		`- Cluster::Array(info, dim) => ClusterArray {`
	`67`	`+ Self::Single(info) => info.serialize(serializer),`
	`68`	`+ Self::Array(info, dim) => ClusterArray {`
`58`	`69`	`dim: Some(dim.clone()),`
`59`	`70`	`info: info.clone(),`
`60`	`71`	`}`
`@@ -70,9 +81,9 @@ mod ser_de {`
`70`	`81`	`{`
`71`	`82`	`let ClusterArray { dim, info } = ClusterArray::deserialize(deserializer)?;`
`72`	`83`	`if let Some(dim) = dim {`
`73`		`- Ok(Cluster::Array(info, dim))`
	`84`	`+ Ok(info.array(dim))`
`74`	`85`	`} else {`
`75`		`- Ok(Cluster::Single(info))`
	`86`	`+ Ok(info.single())`
`76`	`87`	`}`
`77`	`88`	`}`
`78`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,21 +15,32 @@ impl Deref for Field {`
`15`	`15`
`16`	`16`	`fn deref(&self) -> &FieldInfo {`
`17`	`17`	`match self {`
`18`		`- Field::Single(info) => info,`
`19`		`- Field::Array(info, _) => info,`
	`18`	`+ Self::Single(info) => info,`
	`19`	`+ Self::Array(info, _) => info,`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`impl DerefMut for Field {`
`25`	`25`	`fn deref_mut(&mut self) -> &mut FieldInfo {`
`26`	`26`	`match self {`
`27`		`- Field::Single(info) => info,`
`28`		`- Field::Array(info, _) => info,`
	`27`	`+ Self::Single(info) => info,`
	`28`	`+ Self::Array(info, _) => info,`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
	`33`	`+impl Field {`
	`34`	+ /// Return `true` if field instance is single
	`35`	`+ pub const fn is_single(&self) -> bool {`
	`36`	`+ matches!(self, Self::Single(_))`
	`37`	`+ }`
	`38`	+ /// Return `true` if it is field array
	`39`	`+ pub const fn is_array(&self) -> bool {`
	`40`	`+ matches!(self, Self::Array(_, _))`
	`41`	`+ }`
	`42`	`+}`
	`43`	`+`
`33`	`44`	`#[cfg(feature = "serde")]`
`34`	`45`	`mod ser_de {`
`35`	`46`	`use super::*;`
`@@ -52,8 +63,8 @@ mod ser_de {`
`52`	`63`	`S: Serializer,`
`53`	`64`	`{`
`54`	`65`	`match self {`
`55`		`- Field::Single(info) => info.serialize(serializer),`
`56`		`- Field::Array(info, dim) => FieldArray {`
	`66`	`+ Self::Single(info) => info.serialize(serializer),`
	`67`	`+ Self::Array(info, dim) => FieldArray {`
`57`	`68`	`dim: Some(dim.clone()),`
`58`	`69`	`info: info.clone(),`
`59`	`70`	`}`
`@@ -69,9 +80,9 @@ mod ser_de {`
`69`	`80`	`{`
`70`	`81`	`let FieldArray { dim, info } = FieldArray::deserialize(deserializer)?;`
`71`	`82`	`if let Some(dim) = dim {`
`72`		`- Ok(Field::Array(info, dim))`
	`83`	`+ Ok(info.array(dim))`
`73`	`84`	`} else {`
`74`		`- Ok(Field::Single(info))`
	`85`	`+ Ok(info.single())`
`75`	`86`	`}`
`76`	`87`	`}`
`77`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,21 +16,32 @@ impl Deref for Peripheral {`
`16`	`16`
`17`	`17`	`fn deref(&self) -> &PeripheralInfo {`
`18`	`18`	`match self {`
`19`		`- Peripheral::Single(info) => info,`
`20`		`- Peripheral::Array(info, _) => info,`
	`19`	`+ Self::Single(info) => info,`
	`20`	`+ Self::Array(info, _) => info,`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`impl DerefMut for Peripheral {`
`26`	`26`	`fn deref_mut(&mut self) -> &mut PeripheralInfo {`
`27`	`27`	`match self {`
`28`		`- Peripheral::Single(info) => info,`
`29`		`- Peripheral::Array(info, _) => info,`
	`28`	`+ Self::Single(info) => info,`
	`29`	`+ Self::Array(info, _) => info,`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
	`34`	`+impl Peripheral {`
	`35`	+ /// Return `true` if peripheral instance is single
	`36`	`+ pub const fn is_single(&self) -> bool {`
	`37`	`+ matches!(self, Self::Single(_))`
	`38`	`+ }`
	`39`	+ /// Return `true` if it is peripheral array
	`40`	`+ pub const fn is_array(&self) -> bool {`
	`41`	`+ matches!(self, Self::Array(_, _))`
	`42`	`+ }`
	`43`	`+}`
	`44`	`+`
`34`	`45`	`#[cfg(feature = "serde")]`
`35`	`46`	`mod ser_de {`
`36`	`47`	`use super::*;`
`@@ -53,8 +64,8 @@ mod ser_de {`
`53`	`64`	`S: Serializer,`
`54`	`65`	`{`
`55`	`66`	`match self {`
`56`		`- Peripheral::Single(info) => info.serialize(serializer),`
`57`		`- Peripheral::Array(info, dim) => PeripheralArray {`
	`67`	`+ Self::Single(info) => info.serialize(serializer),`
	`68`	`+ Self::Array(info, dim) => PeripheralArray {`
`58`	`69`	`dim: Some(dim.clone()),`
`59`	`70`	`info: info.clone(),`
`60`	`71`	`}`
`@@ -70,9 +81,9 @@ mod ser_de {`
`70`	`81`	`{`
`71`	`82`	`let PeripheralArray { dim, info } = PeripheralArray::deserialize(deserializer)?;`
`72`	`83`	`if let Some(dim) = dim {`
`73`		`- Ok(Peripheral::Array(info, dim))`
	`84`	`+ Ok(info.array(dim))`
`74`	`85`	`} else {`
`75`		`- Ok(Peripheral::Single(info))`
	`86`	`+ Ok(info.single())`
`76`	`87`	`}`
`77`	`88`	`}`
`78`	`89`	`}`