Implements DoubleEndedIterator for Leds

We can reverse now!

Also removed the &Leds version of the iterator,
because you can't do anything useful with it.

Author: rubberduck203

examples/leds_array_indexing.rs renamed to examples/leds.rs

@@ -24,7 +24,7 @@ fn main() -> ! {
 
     // initialize user leds
     let mut gpioe = device_periphs.GPIOE.split(&mut reset_and_clock_control.ahb);
-    let leds = Leds::new(
+    let mut leds = Leds::new(
         gpioe.pe8,
         gpioe.pe9,
         gpioe.pe10,
@@ -37,17 +37,13 @@ fn main() -> ! {
         &mut gpioe.otyper,
     );
 
-    let mut compass = leds.into_array();
-
     loop {
         let ms_delay = 50u16;
-        let ubound = compass.len();
-        for curr in 0..ubound {
-            let next = (curr + 1) % ubound;
 
-            compass[next].on().ok();
+        for led in &mut leds {
+            led.on().ok();
             delay.delay_ms(ms_delay);
-            compass[curr].off().ok();
+            led.off().ok();
             delay.delay_ms(ms_delay);
         }
     }

examples/leds_array_iterator.rs renamed to examples/leds_iterator_test.rs

@@ -41,19 +41,43 @@ fn main() -> ! {
 
     loop {
         let ms_delay = 50u16;
-        // Alternative way to iterate through lights
-        // do it backwards because it's fun and easy
-        // for led in compass.iter_mut().rev() {
-        //     led.on().ok();
-        //     delay.delay_ms(ms_delay);
-        //     led.off().ok();
-        //     delay.delay_ms(ms_delay);
-        // }
-        for led in &mut leds {
+
+        // iterate through the leds in reverse
+        for led in leds.iter_mut().rev() {
             led.on().ok();
             delay.delay_ms(ms_delay);
             led.off().ok();
             delay.delay_ms(ms_delay);
         }
+
+        delay.delay_ms(ms_delay);
+
+        // verify we stop when meeting in the middle
+        let mut iter = leds.iter_mut();
+        iter.next().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next_back().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next_back().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next_back().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        iter.next_back().map(|led| led.on().ok());
+        delay.delay_ms(ms_delay);
+        // we're in the middle, so panic if either of the next two calls returns a led
+        iter.next().map(|_| panic!("Got a Some!"));
+        iter.next_back().map(|_| panic!("Got a Some!"));
+        
+        // turn everything back off
+        for led in &mut leds {
+            led.off().ok();
+            delay.delay_ms(ms_delay);
+        }
     }
 }

src/leds.rs

@@ -128,10 +128,6 @@ impl Leds {
         }
     }
 
-    pub fn iter(&self) -> LedsIterator {
-        LedsIterator::new(self)
-    }
-
     pub fn iter_mut(&mut self) -> LedsMutIterator {
         LedsMutIterator::new(self)
     }
@@ -154,15 +150,6 @@ impl Leds {
     }
 }
 
-impl<'a> IntoIterator for &'a Leds {
-    type Item = &'a Led;
-    type IntoIter = LedsIterator<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
 impl<'a> IntoIterator for &'a mut Leds {
     type Item = &'a mut Led;
     type IntoIter = LedsMutIterator<'a>;
@@ -172,73 +159,21 @@ impl<'a> IntoIterator for &'a mut Leds {
     }
 }
 
-pub struct LedsIterator<'a> {
-    current_index: usize,
-    leds: &'a Leds
-}
-
-impl<'a> LedsIterator<'a> {
-    fn new(leds: &'a Leds) -> Self {
-        LedsIterator { current_index: 0, leds }
-    }
-
-    fn len(&self) -> usize {
-        ITERATOR_SIZE - self.current_index
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let length = self.len();
-        (length, Some(length))
-    }
-}
-
-impl<'a> Iterator for LedsIterator<'a> {
-    type Item = &'a Led;
-    fn next(&mut self) -> Option<Self::Item> {
-        let current = match self.current_index {
-            0 => Some(&self.leds.ld3),  //N
-            1 => Some(&self.leds.ld5),  //NE
-            2 => Some(&self.leds.ld7),  //E
-            3 => Some(&self.leds.ld9),  //SE
-            4 => Some(&self.leds.ld10), //S
-            5 => Some(&self.leds.ld8),  //SW
-            6 => Some(&self.leds.ld6),  //W
-            7 => Some(&self.leds.ld4),  //NW
-            _ => None
-        };
-        self.current_index += 1;
-        current
-    }
-
-    // Because we implement ExactSizedIterator, we need to ensure size_hint returns the right length
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.size_hint()
-    }
-}
-
 const ITERATOR_SIZE: usize = 8;
 
-impl<'a> ExactSizeIterator for LedsIterator<'a> {
-    fn len(&self) -> usize {
-        self.len()
-    }
-}
-
-///Marker trait that indicates LedsIterator never starts returning Some after returning None
-impl<'a> FusedIterator for LedsIterator<'a> {}
-
 pub struct LedsMutIterator<'a> {
-    current_index: usize,
+    index: usize,
+    index_back: usize,
     leds: &'a mut Leds
 }
 
 impl<'a> LedsMutIterator<'a> {
     fn new(leds: &'a mut Leds) -> Self {
-        LedsMutIterator { current_index: 0, leds }
+        LedsMutIterator { index: 0, index_back: ITERATOR_SIZE, leds }
     }
 
     fn len(&self) -> usize {
-        ITERATOR_SIZE - self.current_index
+        self.index_back - self.index
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -250,23 +185,28 @@ impl<'a> LedsMutIterator<'a> {
 impl<'a> Iterator for LedsMutIterator<'a> {
     type Item = &'a mut Led;
     fn next(&mut self) -> Option<Self::Item> {
-        let current = unsafe {
-            //Safety: Each branch is only executed once,
-            // so we can not possibly alias a mutable reference.
-                match self.current_index {
-                    0 => Some(&mut *(&mut self.leds.ld3 as *mut _)),  //N
-                    1 => Some(&mut *(&mut self.leds.ld5 as *mut _)),  //NE
-                    2 => Some(&mut *(&mut self.leds.ld7 as *mut _)),  //E
-                    3 => Some(&mut *(&mut self.leds.ld9 as *mut _)),  //SE
-                    4 => Some(&mut *(&mut self.leds.ld10 as *mut _)), //S
-                    5 => Some(&mut *(&mut self.leds.ld8 as *mut _)),  //SW
-                    6 => Some(&mut *(&mut self.leds.ld6 as *mut _)),  //W
-                    7 => Some(&mut *(&mut self.leds.ld4 as *mut _)),  //NW
-                    _ => None
-            }
-        };
-        self.current_index += 1;
-        current
+        if self.len() == 0 {
+            None
+        } else {
+            let current = unsafe {
+                //Safety: Each branch is only executed once,
+                // so we can not possibly alias a mutable reference.
+                // Oddly, this depends on DoubleSidedIterator also being implemented correctly.
+                    match self.index {
+                        0 => Some(&mut *(&mut self.leds.ld3 as *mut _)),  //N
+                        1 => Some(&mut *(&mut self.leds.ld5 as *mut _)),  //NE
+                        2 => Some(&mut *(&mut self.leds.ld7 as *mut _)),  //E
+                        3 => Some(&mut *(&mut self.leds.ld9 as *mut _)),  //SE
+                        4 => Some(&mut *(&mut self.leds.ld10 as *mut _)), //S
+                        5 => Some(&mut *(&mut self.leds.ld8 as *mut _)),  //SW
+                        6 => Some(&mut *(&mut self.leds.ld6 as *mut _)),  //W
+                        7 => Some(&mut *(&mut self.leds.ld4 as *mut _)),  //NW
+                        _ => None
+                }
+            };
+            self.index += 1;
+            current
+        }
     }
 
     // Because we implement ExactSizedIterator, we need to ensure size_hint returns the right length
@@ -275,9 +215,42 @@ impl<'a> Iterator for LedsMutIterator<'a> {
     }
 }
 
+impl<'a> DoubleEndedIterator for LedsMutIterator<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> { 
+        if self.len() == 0 {
+            None
+        } else {
+            let current = unsafe {
+                //Safety: Each branch is only executed once,
+                // and only if there are elements left to be returned, 
+                // so we can not possibly alias a mutable reference.
+                // This depends on Iterator and ExactSizedIterator being implemented correctly.
+                // If len() does not return the correct number of remaining elements, 
+                // this becomes unsound.
+                    match self.index_back {
+                        // Because we're going backwards and index_back is a usize,
+                        // We use a one based index so we don't go negative
+                        0 => None, //done
+                        1 => Some(&mut *(&mut self.leds.ld3 as *mut _)),  //N
+                        2 => Some(&mut *(&mut self.leds.ld5 as *mut _)),  //NE
+                        3 => Some(&mut *(&mut self.leds.ld7 as *mut _)),  //E
+                        4 => Some(&mut *(&mut self.leds.ld9 as *mut _)),  //SE
+                        5 => Some(&mut *(&mut self.leds.ld10 as *mut _)), //S
+                        6 => Some(&mut *(&mut self.leds.ld8 as *mut _)),  //SW
+                        7 => Some(&mut *(&mut self.leds.ld6 as *mut _)),  //W
+                        8 => Some(&mut *(&mut self.leds.ld4 as *mut _)),  //NW
+                        _ => None //can't happen
+                }
+            };
+            self.index_back -= 1;
+            current
+        }
+    }
+}
+
 impl<'a> ExactSizeIterator for LedsMutIterator<'a> {
     fn len(&self) -> usize {
-        ITERATOR_SIZE - self.current_index
+        self.len()
     }
 }