Add mutable iterator and rename values to iter

sfackler · sfackler · commit 8688f4b5cfef · 2015-05-19T21:31:27.000-07:00
diff --git a/src/impls/mod.rs b/src/impls/mod.rs
@@ -71,7 +71,7 @@ impl<T> ToSql for ArrayBase<Option<T>> where T: ToSql {
             try!(w.write_i32::<BigEndian>(info.lower_bound as i32));
         }
 
-        for v in self.values() {
+        for v in self {
             match *v {
                 Some(ref val) => {
                     let mut inner_buf = vec![];
diff --git a/src/lib.rs b/src/lib.rs
@@ -151,10 +151,38 @@ impl<T> ArrayBase<T> {
         self.data.extend(other.data.into_iter());
     }
 
-    /// Returns an iterator over the values in this array, in the
+    /// Returns an iterator over references to the values in this array, in the
     /// higher-dimensional equivalent of row-major order.
-    pub fn values<'a>(&'a self) -> slice::Iter<'a, T> {
-        self.data.iter()
+    pub fn iter<'a>(&'a self) -> ArrayBaseIter<'a, T> {
+        ArrayBaseIter {
+            inner: self.data.iter(),
+        }
+    }
+
+    /// Returns an iterator over references to the values in this array, in the
+    /// higher-dimensional equivalent of row-major order.
+    pub fn iter_mut<'a>(&'a mut self) -> ArrayBaseIterMut<'a, T> {
+        ArrayBaseIterMut {
+            inner: self.data.iter_mut(),
+        }
+    }
+}
+
+impl<'a, T: 'a> IntoIterator for &'a ArrayBase<T> {
+    type Item = &'a T;
+    type IntoIter = ArrayBaseIter<'a, T>;
+
+    fn into_iter(self) -> ArrayBaseIter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T: 'a> IntoIterator for &'a mut ArrayBase<T> {
+    type Item = &'a mut T;
+    type IntoIter = ArrayBaseIterMut<'a, T>;
+
+    fn into_iter(self) -> ArrayBaseIterMut<'a, T> {
+        self.iter_mut()
     }
 }
 
@@ -169,15 +197,6 @@ impl<T> IntoIterator for ArrayBase<T> {
     }
 }
 
-impl<'a, T> IntoIterator for &'a ArrayBase<T> {
-    type Item = &'a T;
-    type IntoIter = slice::Iter<'a, T>;
-
-    fn into_iter(self) -> slice::Iter<'a, T> {
-        self.values()
-    }
-}
-
 impl<T> Array<T> for ArrayBase<T> {
     fn dimension_info<'a>(&'a self) -> &'a [DimensionInfo] {
         &*self.info
@@ -229,8 +248,48 @@ impl<T> InternalMutableArray<T> for ArrayBase<T> {
     }
 }
 
+/// An iterator over references to values of an `ArrayBase` in the
+/// higher-dimensional equivalent of row-major order.
+pub struct ArrayBaseIter<'a, T: 'a> {
+    inner: slice::Iter<'a, T>,
+}
+
+impl<'a, T: 'a> Iterator for ArrayBaseIter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<&'a T> {
+        self.inner.next()
+    }
+}
+
+impl<'a, T: 'a> DoubleEndedIterator for ArrayBaseIter<'a, T> {
+    fn next_back(&mut self) -> Option<&'a T> {
+        self.inner.next_back()
+    }
+}
+
+/// An iterator over mutable references to values of an `ArrayBase` in the
+/// higher-dimensional equivalent of row-major order.
+pub struct ArrayBaseIterMut<'a, T: 'a> {
+    inner: slice::IterMut<'a, T>,
+}
+
+impl<'a, T: 'a> Iterator for ArrayBaseIterMut<'a, T> {
+    type Item = &'a mut T;
+
+    fn next(&mut self) -> Option<&'a mut T> {
+        self.inner.next()
+    }
+}
+
+impl<'a, T: 'a> DoubleEndedIterator for ArrayBaseIterMut<'a, T> {
+    fn next_back(&mut self) -> Option<&'a mut T> {
+        self.inner.next_back()
+    }
+}
+
 /// An iterator over values of an `ArrayBase` in the higher-dimensional
-/// equivalent of row major order.
+/// equivalent of row-major order.
 pub struct ArrayBaseIntoIter<T> {
     inner: vec::IntoIter<T>,
 }

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ impl<T> ToSql for ArrayBase<Option<T>> where T: ToSql {`
`71`	`71`	`try!(w.write_i32::<BigEndian>(info.lower_bound as i32));`
`72`	`72`	`}`
`73`	`73`
`74`		`- for v in self.values() {`
	`74`	`+ for v in self {`
`75`	`75`	`match *v {`
`76`	`76`	`Some(ref val) => {`
`77`	`77`	`let mut inner_buf = vec![];`