@@ -3,8 +3,8 @@ use super::{
3
3
AllRegistersIter , AllRegistersIterMut , ClusterIter , ClusterIterMut , RegisterIter ,
4
4
RegisterIterMut ,
5
5
} ,
6
- AddressBlock , BuildError , Cluster , DimElement , EmptyToNone , Interrupt , OptIter , Peripheral ,
7
- Register , RegisterCluster , RegisterProperties , SvdError , ValidateLevel ,
6
+ AddressBlock , BuildError , Cluster , DimElement , EmptyToNone , Interrupt , Peripheral , Register ,
7
+ RegisterCluster , RegisterProperties , SvdError , ValidateLevel ,
8
8
} ;
9
9
10
10
/// Errors from [Peripheral::validate]
@@ -361,35 +361,43 @@ impl PeripheralInfo {
361
361
}
362
362
363
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
- )
364
+ pub fn registers ( & self ) -> RegisterIter {
365
+ RegisterIter {
366
+ all : match & self . registers {
367
+ Some ( regs) => regs. iter ( ) ,
368
+ None => [ ] . iter ( ) ,
369
+ } ,
370
+ }
370
371
}
371
372
372
373
/// 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
- } ) )
374
+ pub fn registers_mut ( & mut self ) -> RegisterIterMut {
375
+ RegisterIterMut {
376
+ all : match & mut self . registers {
377
+ Some ( regs) => regs. iter_mut ( ) ,
378
+ None => [ ] . iter_mut ( ) ,
379
+ } ,
380
+ }
377
381
}
378
382
379
383
/// 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
- )
384
+ pub fn clusters ( & self ) -> ClusterIter {
385
+ ClusterIter {
386
+ all : match & self . registers {
387
+ Some ( regs) => regs. iter ( ) ,
388
+ None => [ ] . iter ( ) ,
389
+ } ,
390
+ }
386
391
}
387
392
388
393
/// 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
- } ) )
394
+ pub fn clusters_mut ( & mut self ) -> ClusterIterMut {
395
+ ClusterIterMut {
396
+ all : match & mut self . registers {
397
+ Some ( regs) => regs. iter_mut ( ) ,
398
+ None => [ ] . iter_mut ( ) ,
399
+ } ,
400
+ }
393
401
}
394
402
395
403
/// Returns iterator over all descendant registers
@@ -400,14 +408,11 @@ impl PeripheralInfo {
400
408
401
409
/// Returns iterator over all descendant registers
402
410
pub fn all_registers ( & self ) -> AllRegistersIter {
403
- if let Some ( regs) = & self . registers {
404
- let mut rem: Vec < & RegisterCluster > = Vec :: with_capacity ( regs. len ( ) ) ;
405
- for r in regs. iter ( ) . rev ( ) {
406
- rem. push ( r) ;
407
- }
408
- AllRegistersIter { rem }
409
- } else {
410
- AllRegistersIter { rem : Vec :: new ( ) }
411
+ AllRegistersIter {
412
+ rem : match & self . registers {
413
+ Some ( regs) => regs. iter ( ) . rev ( ) . collect ( ) ,
414
+ None => Vec :: new ( ) ,
415
+ } ,
411
416
}
412
417
}
413
418
@@ -419,14 +424,11 @@ impl PeripheralInfo {
419
424
420
425
/// Returns mutable iterator over all descendant registers
421
426
pub fn all_registers_mut ( & mut self ) -> AllRegistersIterMut {
422
- if let Some ( regs) = & mut self . registers {
423
- let mut rem: Vec < & mut RegisterCluster > = Vec :: with_capacity ( regs. len ( ) ) ;
424
- for r in regs. iter_mut ( ) . rev ( ) {
425
- rem. push ( r) ;
426
- }
427
- AllRegistersIterMut { rem }
428
- } else {
429
- AllRegistersIterMut { rem : Vec :: new ( ) }
427
+ AllRegistersIterMut {
428
+ rem : match & mut self . registers {
429
+ Some ( regs) => regs. iter_mut ( ) . rev ( ) . collect ( ) ,
430
+ None => Vec :: new ( ) ,
431
+ } ,
430
432
}
431
433
}
432
434
0 commit comments