Implement DoubleEndedIterator for Iter

Author: Ten0

src/btree_multiset.rs

@@ -62,13 +62,7 @@ where
     /// assert_eq!(3, multiset.iter().count());
     /// ```
     pub fn iter(&self) -> Iter<&K, &usize, btree_map::Iter<K, usize>> {
-        Iter {
-            iter: self.elem_counts.iter(),
-            duplicate: None,
-            duplicate_index: 0,
-            len: self.size,
-            _ghost: std::marker::PhantomData,
-        }
+        Iter::new(self.elem_counts.iter(), self.size)
     }
 
     /// Returns true if the multiset contains no elements.

src/hash_multiset.rs

@@ -63,13 +63,7 @@ where
     /// assert_eq!(3, multiset.iter().count());
     /// ```
     pub fn iter(&self) -> Iter<&K, &usize, hash_map::Iter<K, usize>> {
-        Iter {
-            iter: self.elem_counts.iter(),
-            duplicate: None,
-            duplicate_index: 0,
-            len: self.size,
-            _ghost: std::marker::PhantomData,
-        }
+        Iter::new(self.elem_counts.iter(), self.size)
     }
 
     /// Returns true if the multiset contains no elements.

src/iter.rs

@@ -18,10 +18,28 @@ pub struct Iter<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)>>
     pub(crate) iter: InnerIter,
     pub(crate) duplicate: Option<<InnerIter as Iterator>::Item>,
     pub(crate) duplicate_index: usize,
+    pub(crate) duplicate_back: Option<<InnerIter as Iterator>::Item>,
+    pub(crate) duplicate_index_back: usize,
     pub(crate) len: usize,
     pub(crate) _ghost: PhantomData<*const (K, V)>,
 }
 
+impl<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)> + ExactSizeIterator>
+    Iter<K, V, InnerIter>
+{
+    pub(crate) fn new(iter: InnerIter, len: usize) -> Self {
+        Iter {
+            iter,
+            duplicate: None,
+            duplicate_index: 0,
+            duplicate_back: None,
+            duplicate_index_back: 0,
+            len,
+            _ghost: PhantomData,
+        }
+    }
+}
+
 impl<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)> + Clone> Clone
     for Iter<K, V, InnerIter>
 where
@@ -32,6 +50,8 @@ where
             iter: self.iter.clone(),
             duplicate: self.duplicate.clone(),
             duplicate_index: self.duplicate_index,
+            duplicate_back: self.duplicate_back.clone(),
+            duplicate_index_back: self.duplicate_index_back,
             len: self.len,
             _ghost: PhantomData,
         }
@@ -50,14 +70,24 @@ impl<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)>> Iterator
         if let Some((key, count)) = self.duplicate.as_ref() {
             self.duplicate_index += 1;
             let key = key.clone();
-            if &self.duplicate_index >= count.borrow() {
+            if self.duplicate_index >= *count.borrow() {
                 self.duplicate = None;
                 self.duplicate_index = 0;
             }
             self.len -= 1;
             Some(key)
         } else {
-            None
+            if let Some((key, count)) = self.duplicate_back.as_ref() {
+                self.duplicate_index_back += 1;
+                let key = key.clone();
+                if self.duplicate_index_back >= *count.borrow() {
+                    self.duplicate_back = None;
+                }
+                self.len -= 1;
+                Some(key)
+            } else {
+                None
+            }
         }
     }
 
@@ -70,10 +100,16 @@ impl<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)>> Iterator
         F: FnMut(B, Self::Item) -> B,
     {
         let duplicate_index = self.duplicate_index;
+        let duplicate_index_back = self.duplicate_index_back;
         self.duplicate
             .map(move |(val, count)| (val, *count.borrow() - duplicate_index))
             .into_iter()
             .chain(self.iter.map(move |(val, count)| (val, *count.borrow())))
+            .chain(
+                self.duplicate_back
+                    .map(move |(val, count)| (val, *count.borrow() - duplicate_index_back))
+                    .into_iter(),
+            )
             .fold(init, move |acc, (val, count)| {
                 (0..count).fold(acc, |acc, _| f(acc, val.clone()))
             })
@@ -92,3 +128,59 @@ impl<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)>> ExactSizeIt
         self.len
     }
 }
+
+impl<K: Clone, V: Borrow<usize>, InnerIter: Iterator<Item = (K, V)> + DoubleEndedIterator>
+    DoubleEndedIterator for Iter<K, V, InnerIter>
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.duplicate_back.is_none() {
+            self.duplicate_back = self.iter.next_back();
+        }
+        if let Some((key, count)) = self.duplicate_back.as_ref() {
+            self.duplicate_index_back += 1;
+            let key = key.clone();
+            if self.duplicate_index_back >= *count.borrow() {
+                self.duplicate_back = None;
+                self.duplicate_index_back = 0;
+            }
+            self.len -= 1;
+            Some(key)
+        } else {
+            if let Some((key, count)) = self.duplicate.as_ref() {
+                self.duplicate_index += 1;
+                let key = key.clone();
+                if self.duplicate_index >= *count.borrow() {
+                    self.duplicate = None;
+                }
+                self.len -= 1;
+                Some(key)
+            } else {
+                None
+            }
+        }
+    }
+
+    fn rfold<B, F>(self, init: B, mut f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        let duplicate_index = self.duplicate_index;
+        let duplicate_index_back = self.duplicate_index_back;
+        self.duplicate_back
+            .map(move |(val, count)| (val, *count.borrow() - duplicate_index_back))
+            .into_iter()
+            .chain(
+                self.iter
+                    .rev()
+                    .map(move |(val, count)| (val, *count.borrow())),
+            )
+            .chain(
+                self.duplicate
+                    .map(move |(val, count)| (val, *count.borrow() - duplicate_index))
+                    .into_iter(),
+            )
+            .fold(init, move |acc, (val, count)| {
+                (0..count).fold(acc, |acc, _| f(acc, val.clone()))
+            })
+    }
+}