Skip to content

Commit 9b28ccb

Browse files
burrbullburrbull
committed
register, cluster iterators
1 parent c802dd1 commit 9b28ccb

File tree

5 files changed

+248
-65
lines changed

5 files changed

+248
-65
lines changed

‎svd-rs/CHANGELOG.md‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
77

88
## Unreleased
99

10+
- Rename `reg_iter` to `all_registers`, add `registers`, `clusters` methods that create iterators
11+
1012
## [v0.12.0] - 2021-11-11
1113

1214
- Bump dependencies

‎svd-rs/src/clusterinfo.rs‎

Lines changed: 50 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
use super::{
2-
register::{RegIter, RegIterMut},
2+
registercluster::{
3+
AllRegistersIter, AllRegistersIterMut, ClusterIter, ClusterIterMut, RegisterIter,
4+
RegisterIterMut,
5+
},
36
BuildError, Cluster, DimElement, EmptyToNone, RegisterCluster, RegisterProperties, SvdError,
47
ValidateLevel,
58
};
@@ -226,21 +229,61 @@ impl ClusterInfo {
226229
Ok(())
227230
}
228231

229-
/// returns a iterator over all registers the cluster contains
230-
pub fn reg_iter(&self) -> RegIter {
232+
/// Returns iterator over all descendant registers
233+
#[deprecated(since = "0.12.1", note = "Please use `all_registers` instead")]
234+
pub fn reg_iter(&self) -> AllRegistersIter {
235+
self.all_registers()
236+
}
237+
238+
/// Returns iterator over all descendant registers
239+
pub fn all_registers(&self) -> AllRegistersIter {
231240
let mut rem: Vec<&RegisterCluster> = Vec::with_capacity(self.children.len());
232241
for r in self.children.iter().rev() {
233242
rem.push(r);
234243
}
235-
RegIter { rem }
244+
AllRegistersIter { rem }
245+
}
246+
247+
/// Returns mutable iterator over all descendant registers
248+
#[deprecated(since = "0.12.1", note = "Please use `all_registers_mut` instead")]
249+
pub fn reg_iter_mut(&mut self) -> AllRegistersIterMut {
250+
self.all_registers_mut()
236251
}
237252

238-
/// returns a mutable iterator over all registers cluster contains
239-
pub fn reg_iter_mut(&mut self) -> RegIterMut {
253+
/// Returns mutable iterator over all descendant registers
254+
pub fn all_registers_mut(&mut self) -> AllRegistersIterMut {
240255
let mut rem: Vec<&mut RegisterCluster> = Vec::with_capacity(self.children.len());
241256
for r in self.children.iter_mut().rev() {
242257
rem.push(r);
243258
}
244-
RegIterMut { rem }
259+
AllRegistersIterMut { rem }
260+
}
261+
262+
/// Returns iterator over child registers
263+
pub fn registers(&self) -> RegisterIter {
264+
RegisterIter {
265+
all: self.children.iter(),
266+
}
267+
}
268+
269+
/// Returns mutable iterator over child registers
270+
pub fn registers_mut(&mut self) -> RegisterIterMut {
271+
RegisterIterMut {
272+
all: self.children.iter_mut(),
273+
}
274+
}
275+
276+
/// Returns iterator over child clusters
277+
pub fn clusters(&self) -> ClusterIter {
278+
ClusterIter {
279+
all: self.children.iter(),
280+
}
281+
}
282+
283+
/// Returns mutable iterator over child clusters
284+
pub fn clusters_mut(&mut self) -> ClusterIterMut {
285+
ClusterIterMut {
286+
all: self.children.iter_mut(),
287+
}
245288
}
246289
}

‎svd-rs/src/peripheralinfo.rs‎

Lines changed: 56 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
use super::{
2-
register::{RegIter, RegIterMut},
2+
registercluster::{
3+
AllRegistersIter, AllRegistersIterMut, ClusterIter, ClusterIterMut, OptIter, RegisterIter,
4+
RegisterIterMut,
5+
},
36
AddressBlock, BuildError, DimElement, EmptyToNone, Interrupt, Peripheral, RegisterCluster,
47
RegisterProperties, SvdError, ValidateLevel,
58
};
@@ -357,29 +360,73 @@ impl PeripheralInfo {
357360
Ok(())
358361
}
359362

360-
/// returns iterator over all registers peripheral contains
361-
pub fn reg_iter(&self) -> RegIter {
363+
/// Returns iterator over child registers
364+
pub fn registers(&self) -> OptIter<RegisterIter> {
365+
OptIter::new(
366+
self.registers
367+
.as_ref()
368+
.map(|regs| RegisterIter { all: regs.iter() }),
369+
)
370+
}
371+
372+
/// Returns mutable iterator over child registers
373+
pub fn registers_mut(&mut self) -> OptIter<RegisterIterMut> {
374+
OptIter::new(self.registers.as_mut().map(|regs| RegisterIterMut {
375+
all: regs.iter_mut(),
376+
}))
377+
}
378+
379+
/// Returns iterator over child clusters
380+
pub fn clusters(&self) -> OptIter<ClusterIter> {
381+
OptIter::new(
382+
self.registers
383+
.as_ref()
384+
.map(|regs| ClusterIter { all: regs.iter() }),
385+
)
386+
}
387+
388+
/// Returns mutable iterator over child clusters
389+
pub fn clusters_mut(&mut self) -> OptIter<ClusterIterMut> {
390+
OptIter::new(self.registers.as_mut().map(|regs| ClusterIterMut {
391+
all: regs.iter_mut(),
392+
}))
393+
}
394+
395+
/// Returns iterator over all descendant registers
396+
#[deprecated(since = "0.12.1", note = "Please use `all_registers` instead")]
397+
pub fn reg_iter(&self) -> AllRegistersIter {
398+
self.all_registers()
399+
}
400+
401+
/// Returns iterator over all descendant registers
402+
pub fn all_registers(&self) -> AllRegistersIter {
362403
if let Some(regs) = &self.registers {
363404
let mut rem: Vec<&RegisterCluster> = Vec::with_capacity(regs.len());
364405
for r in regs.iter().rev() {
365406
rem.push(r);
366407
}
367-
RegIter { rem }
408+
AllRegistersIter { rem }
368409
} else {
369-
RegIter { rem: Vec::new() }
410+
AllRegistersIter { rem: Vec::new() }
370411
}
371412
}
372413

373-
/// returns mutable iterator over all registers peripheral contains
374-
pub fn reg_iter_mut(&mut self) -> RegIterMut {
414+
/// Returns mutable iterator over all descendant registers
415+
#[deprecated(since = "0.12.1", note = "Please use `all_registers_mut` instead")]
416+
pub fn reg_iter_mut(&mut self) -> AllRegistersIterMut {
417+
self.all_registers_mut()
418+
}
419+
420+
/// Returns mutable iterator over all descendant registers
421+
pub fn all_registers_mut(&mut self) -> AllRegistersIterMut {
375422
if let Some(regs) = &mut self.registers {
376423
let mut rem: Vec<&mut RegisterCluster> = Vec::with_capacity(regs.len());
377424
for r in regs.iter_mut().rev() {
378425
rem.push(r);
379426
}
380-
RegIterMut { rem }
427+
AllRegistersIterMut { rem }
381428
} else {
382-
RegIterMut { rem: Vec::new() }
429+
AllRegistersIterMut { rem: Vec::new() }
383430
}
384431
}
385432
}

‎svd-rs/src/register.rs‎

Lines changed: 3 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
use core::ops::{Deref, DerefMut};
22

3-
use super::{DimElement, RegisterCluster, RegisterInfo};
3+
#[doc(hidden)]
4+
pub use super::registercluster::{AllRegistersIter as RegIter, AllRegistersIterMut as RegIterMut};
5+
use super::{DimElement, RegisterInfo};
46

57
/// A single register or array of registers. A register is a named, programmable resource that belongs to a [peripheral](crate::Peripheral).
68
#[derive(Clone, Debug, PartialEq)]
@@ -42,54 +44,6 @@ impl Register {
4244
}
4345
}
4446

45-
/// Register iterator
46-
pub struct RegIter<'a> {
47-
pub(crate) rem: Vec<&'a RegisterCluster>,
48-
}
49-
50-
impl<'a> std::iter::Iterator for RegIter<'a> {
51-
type Item = &'a Register;
52-
fn next(&mut self) -> Option<Self::Item> {
53-
while let Some(b) = self.rem.pop() {
54-
match b {
55-
RegisterCluster::Register(reg) => {
56-
return Some(reg);
57-
}
58-
RegisterCluster::Cluster(cluster) => {
59-
for c in cluster.children.iter().rev() {
60-
self.rem.push(c);
61-
}
62-
}
63-
}
64-
}
65-
None
66-
}
67-
}
68-
69-
/// Mutable register iterator
70-
pub struct RegIterMut<'a> {
71-
pub(crate) rem: Vec<&'a mut RegisterCluster>,
72-
}
73-
74-
impl<'a> std::iter::Iterator for RegIterMut<'a> {
75-
type Item = &'a mut Register;
76-
fn next(&mut self) -> Option<Self::Item> {
77-
while let Some(b) = self.rem.pop() {
78-
match b {
79-
RegisterCluster::Register(reg) => {
80-
return Some(reg);
81-
}
82-
RegisterCluster::Cluster(cluster) => {
83-
for c in cluster.children.iter_mut().rev() {
84-
self.rem.push(c);
85-
}
86-
}
87-
}
88-
}
89-
None
90-
}
91-
}
92-
9347
#[cfg(feature = "serde")]
9448
mod ser_de {
9549
use super::*;

‎svd-rs/src/registercluster.rs‎

Lines changed: 137 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,3 +25,140 @@ impl From<Cluster> for RegisterCluster {
2525
RegisterCluster::Cluster(cluser)
2626
}
2727
}
28+
29+
/// Register iterator
30+
pub struct RegisterIter<'a> {
31+
pub(crate) all: std::slice::Iter<'a, RegisterCluster>,
32+
}
33+
34+
impl<'a> std::iter::Iterator for RegisterIter<'a> {
35+
type Item = &'a Register;
36+
fn next(&mut self) -> Option<Self::Item> {
37+
match self.all.next() {
38+
None => None,
39+
Some(RegisterCluster::Register(reg)) => Some(reg),
40+
_ => self.next(),
41+
}
42+
}
43+
}
44+
45+
/// Mutable register iterator
46+
pub struct RegisterIterMut<'a> {
47+
pub(crate) all: std::slice::IterMut<'a, RegisterCluster>,
48+
}
49+
50+
impl<'a> std::iter::Iterator for RegisterIterMut<'a> {
51+
type Item = &'a mut Register;
52+
fn next(&mut self) -> Option<Self::Item> {
53+
match self.all.next() {
54+
None => None,
55+
Some(RegisterCluster::Register(reg)) => Some(reg),
56+
_ => self.next(),
57+
}
58+
}
59+
}
60+
61+
/// Cluster iterator
62+
pub struct ClusterIter<'a> {
63+
pub(crate) all: std::slice::Iter<'a, RegisterCluster>,
64+
}
65+
66+
impl<'a> std::iter::Iterator for ClusterIter<'a> {
67+
type Item = &'a Cluster;
68+
fn next(&mut self) -> Option<Self::Item> {
69+
match self.all.next() {
70+
None => None,
71+
Some(RegisterCluster::Cluster(c)) => Some(c),
72+
_ => self.next(),
73+
}
74+
}
75+
}
76+
77+
/// Mutable cluster iterator
78+
pub struct ClusterIterMut<'a> {
79+
pub(crate) all: std::slice::IterMut<'a, RegisterCluster>,
80+
}
81+
82+
impl<'a> std::iter::Iterator for ClusterIterMut<'a> {
83+
type Item = &'a mut Cluster;
84+
fn next(&mut self) -> Option<Self::Item> {
85+
match self.all.next() {
86+
None => None,
87+
Some(RegisterCluster::Cluster(c)) => Some(c),
88+
_ => self.next(),
89+
}
90+
}
91+
}
92+
93+
/// Iterator over all registers
94+
pub struct AllRegistersIter<'a> {
95+
pub(crate) rem: Vec<&'a RegisterCluster>,
96+
}
97+
98+
impl<'a> std::iter::Iterator for AllRegistersIter<'a> {
99+
type Item = &'a Register;
100+
fn next(&mut self) -> Option<Self::Item> {
101+
while let Some(b) = self.rem.pop() {
102+
match b {
103+
RegisterCluster::Register(reg) => {
104+
return Some(reg);
105+
}
106+
RegisterCluster::Cluster(cluster) => {
107+
for c in cluster.children.iter().rev() {
108+
self.rem.push(c);
109+
}
110+
}
111+
}
112+
}
113+
None
114+
}
115+
}
116+
117+
/// Mutable iterator over all registers
118+
pub struct AllRegistersIterMut<'a> {
119+
pub(crate) rem: Vec<&'a mut RegisterCluster>,
120+
}
121+
122+
impl<'a> std::iter::Iterator for AllRegistersIterMut<'a> {
123+
type Item = &'a mut Register;
124+
fn next(&mut self) -> Option<Self::Item> {
125+
while let Some(b) = self.rem.pop() {
126+
match b {
127+
RegisterCluster::Register(reg) => {
128+
return Some(reg);
129+
}
130+
RegisterCluster::Cluster(cluster) => {
131+
for c in cluster.children.iter_mut().rev() {
132+
self.rem.push(c);
133+
}
134+
}
135+
}
136+
}
137+
None
138+
}
139+
}
140+
141+
/// Iterates over optional iterator
142+
pub struct OptIter<I>(Option<I>)
143+
where
144+
I: Iterator;
145+
146+
impl<I> OptIter<I>
147+
where
148+
I: Iterator,
149+
{
150+
/// Create new optional iterator
151+
pub fn new(o: Option<I>) -> Self {
152+
Self(o)
153+
}
154+
}
155+
156+
impl<'a, I> Iterator for OptIter<I>
157+
where
158+
I: Iterator,
159+
{
160+
type Item = I::Item;
161+
fn next(&mut self) -> Option<Self::Item> {
162+
self.0.as_mut().and_then(I::next)
163+
}
164+
}

0 commit comments

Comments
 (0)