Merge #144

144: RegIter r=therealprof a=burrbull

r? @therealprof 

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

Author: bors[bot]

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Added `reg_iter`, `reg_iter_mut` methods on `Peripheral` and `Cluster`
+- Added `DerefMut` for `Cluster`, `Register` and `Field`
 - Added `display_name` to `RegisterInfo`
 - Added implementations of `From<Type>` for `TypeBuilder`'s
 

src/svd/cluster.rs

@@ -1,4 +1,4 @@
-use core::ops::Deref;
+use core::ops::{Deref, DerefMut};
 use xmltree::Element;
 
 use crate::types::Parse;
@@ -26,6 +26,15 @@ impl Deref for Cluster {
     }
 }
 
+impl DerefMut for Cluster {
+    fn deref_mut(&mut self) -> &mut ClusterInfo {
+        match self {
+            Cluster::Single(info) => info,
+            Cluster::Array(info, _) => info,
+        }
+    }
+}
+
 impl Parse for Cluster {
     type Object = Self;
     type Error = anyhow::Error;

src/svd/clusterinfo.rs

@@ -7,7 +7,11 @@ use crate::encode::{Encode, EncodeChildren};
 use crate::new_element;
 
 use crate::error::*;
-use crate::svd::{registercluster::RegisterCluster, registerproperties::RegisterProperties};
+use crate::svd::{
+    register::{RegIter, RegIterMut},
+    registercluster::RegisterCluster,
+    registerproperties::RegisterProperties,
+};
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[derive(Clone, Debug, PartialEq)]
@@ -161,6 +165,24 @@ impl ClusterInfo {
             })
             .build()
     }
+
+    /// returns iterator over all registers cluster contains
+    pub fn reg_iter(&self) -> RegIter {
+        let mut rem: Vec<&RegisterCluster> = Vec::with_capacity(self.children.len());
+        for r in self.children.iter().rev() {
+            rem.push(r);
+        }
+        RegIter { rem }
+    }
+
+    /// returns mutable iterator over all registers cluster contains
+    pub fn reg_iter_mut(&mut self) -> RegIterMut {
+        let mut rem: Vec<&mut RegisterCluster> = Vec::with_capacity(self.children.len());
+        for r in self.children.iter_mut().rev() {
+            rem.push(r);
+        }
+        RegIterMut { rem }
+    }
 }
 
 impl Encode for ClusterInfo {

src/svd/field.rs

@@ -1,4 +1,4 @@
-use core::ops::Deref;
+use core::ops::{Deref, DerefMut};
 
 use xmltree::Element;
 
@@ -28,6 +28,15 @@ impl Deref for Field {
     }
 }
 
+impl DerefMut for Field {
+    fn deref_mut(&mut self) -> &mut FieldInfo {
+        match self {
+            Field::Single(info) => info,
+            Field::Array(info, _) => info,
+        }
+    }
+}
+
 impl Parse for Field {
     type Object = Self;
     type Error = anyhow::Error;

src/svd/peripheral.rs

@@ -12,7 +12,10 @@ use crate::types::Parse;
 
 use crate::error::*;
 use crate::svd::{
-    addressblock::AddressBlock, interrupt::Interrupt, registercluster::RegisterCluster,
+    addressblock::AddressBlock,
+    interrupt::Interrupt,
+    register::{RegIter, RegIterMut},
+    registercluster::RegisterCluster,
     registerproperties::RegisterProperties,
 };
 
@@ -185,6 +188,32 @@ impl Peripheral {
         }
         Ok(self)
     }
+
+    /// returns iterator over all registers peripheral contains
+    pub fn reg_iter(&self) -> RegIter {
+        if let Some(regs) = &self.registers {
+            let mut rem: Vec<&RegisterCluster> = Vec::with_capacity(regs.len());
+            for r in regs.iter().rev() {
+                rem.push(r);
+            }
+            RegIter { rem }
+        } else {
+            RegIter { rem: Vec::new() }
+        }
+    }
+
+    /// returns mutable iterator over all registers peripheral contains
+    pub fn reg_iter_mut(&mut self) -> RegIterMut {
+        if let Some(regs) = &mut self.registers {
+            let mut rem: Vec<&mut RegisterCluster> = Vec::with_capacity(regs.len());
+            for r in regs.iter_mut().rev() {
+                rem.push(r);
+            }
+            RegIterMut { rem }
+        } else {
+            RegIterMut { rem: Vec::new() }
+        }
+    }
 }
 
 impl Parse for Peripheral {

src/svd/register.rs

@@ -1,4 +1,4 @@
-use core::ops::Deref;
+use core::ops::{Deref, DerefMut};
 
 use xmltree::Element;
 
@@ -8,7 +8,9 @@ use crate::elementext::ElementExt;
 
 use crate::encode::Encode;
 use crate::error::*;
-use crate::svd::{dimelement::DimElement, registerinfo::RegisterInfo};
+use crate::svd::{
+    dimelement::DimElement, registercluster::RegisterCluster, registerinfo::RegisterInfo,
+};
 use anyhow::Result;
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -29,6 +31,15 @@ impl Deref for Register {
     }
 }
 
+impl DerefMut for Register {
+    fn deref_mut(&mut self) -> &mut RegisterInfo {
+        match self {
+            Register::Single(info) => info,
+            Register::Array(info, _) => info,
+        }
+    }
+}
+
 impl Parse for Register {
     type Object = Self;
     type Error = anyhow::Error;
@@ -103,3 +114,51 @@ mod tests {
         run_test::<Register>(&tests[..]);
     }
 }
+
+/// Register iterator
+pub struct RegIter<'a> {
+    pub(crate) rem: Vec<&'a RegisterCluster>,
+}
+
+impl<'a> std::iter::Iterator for RegIter<'a> {
+    type Item = &'a Register;
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(b) = self.rem.pop() {
+            match b {
+                RegisterCluster::Register(reg) => {
+                    return Some(reg);
+                }
+                RegisterCluster::Cluster(cluster) => {
+                    for c in cluster.children.iter().rev() {
+                        self.rem.push(c);
+                    }
+                }
+            }
+        }
+        None
+    }
+}
+
+/// Mutable register iterator
+pub struct RegIterMut<'a> {
+    pub(crate) rem: Vec<&'a mut RegisterCluster>,
+}
+
+impl<'a> std::iter::Iterator for RegIterMut<'a> {
+    type Item = &'a mut Register;
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(b) = self.rem.pop() {
+            match b {
+                RegisterCluster::Register(reg) => {
+                    return Some(reg);
+                }
+                RegisterCluster::Cluster(cluster) => {
+                    for c in cluster.children.iter_mut().rev() {
+                        self.rem.push(c);
+                    }
+                }
+            }
+        }
+        None
+    }
+}