Add BitFlags::len, improve iterator

- Implemented `BitFlags::len` using `count_ones`.
- Refactored the iterator into a real type, implemented `ExactSizeIterator`
  and `FusedIterator`.
- Implemented `IntoIterator` for `BitFlags`.

`DoubleEndedIterator` is deliberatedly not implemented as to not lock the
implementation down.

Author: chitoyuu

src/lib.rs

@@ -91,7 +91,7 @@
 #![warn(missing_docs)]
 #![cfg_attr(all(not(test), not(feature = "std")), no_std)]
 
-use core::iter::FromIterator;
+use core::iter::{FromIterator, FusedIterator};
 use core::marker::PhantomData;
 use core::{cmp, ops};
 
@@ -232,13 +232,18 @@ pub mod _internal {
     {
         #[doc(hidden)]
         fn is_power_of_two(self) -> bool;
+        #[doc(hidden)]
+        fn count_ones(self) -> u32;
     }
 
     for_each_uint! { $ty $hide_docs =>
         impl BitFlagNum for $ty {
             fn is_power_of_two(self) -> bool {
                 <$ty>::is_power_of_two(self)
             }
+            fn count_ones(self) -> u32 {
+                <$ty>::count_ones(self)
+            }
         }
     }
 
@@ -563,6 +568,12 @@ where
         self.val == T::EMPTY
     }
 
+    /// Returns the number of flags set.
+    #[inline(always)]
+    pub fn len(self) -> usize {
+        self.val.count_ones() as usize
+    }
+
     /// Returns the flag that is set if there is exactly one.
     #[inline(always)]
     pub fn to_flag(self) -> Option<T> {
@@ -626,14 +637,65 @@ where
 
     /// Returns an iterator that yields each set flag
     #[inline]
-    pub fn iter(self) -> impl Iterator<Item = T> + Clone {
-        T::FLAG_LIST
-            .iter()
-            .cloned()
-            .filter(move |&flag| self.contains(flag))
+    pub fn iter(self) -> Iter<T> {
+        Iter {
+            rest: self,
+            it: T::FLAG_LIST.iter(),
+        }
+    }
+}
+
+impl<T: BitFlag> IntoIterator for BitFlags<T> {
+    type IntoIter = Iter<T>;
+    type Item = T;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// Iterator that yields each set flag.
+#[derive(Clone, Debug)]
+pub struct Iter<T: BitFlag> {
+    rest: BitFlags<T>,
+    it: core::slice::Iter<'static, T>,
+}
+
+impl<T> Iterator for Iter<T>
+where
+    T: BitFlag,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        for &flag in &mut self.it {
+            let yes = self.rest.contains(flag);
+            self.rest.remove(flag);
+            if yes {
+                return Some(flag);
+            }
+        }
+
+        None
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let l = self.rest.len();
+        (l, Some(l))
     }
 }
 
+impl<T> ExactSizeIterator for Iter<T>
+where
+    T: BitFlag,
+{
+    fn len(&self) -> usize {
+        self.rest.len()
+    }
+}
+
+impl<T: BitFlag> FusedIterator for Iter<T> {}
+
 for_each_uint! { $ty $hide_docs =>
     impl<T> BitFlags<T, $ty> {
         /// Create a new BitFlags unsafely, without checking if the bits form

test_suite/common.rs

@@ -89,6 +89,14 @@ fn test_to_flag() {
     assert_eq!((Test::A | Test::C).to_flag(), None);
 }
 
+#[test]
+fn test_len() {
+    use enumflags2::BitFlags;
+    assert_eq!(BitFlags::<Test>::empty().len(), 0);
+    assert_eq!(BitFlags::<Test>::all().len(), 4);
+    assert_eq!((Test::A | Test::D).len(), 2);
+}
+
 #[test]
 fn iterator() {
     use enumflags2::BitFlags;
@@ -105,6 +113,14 @@ fn iterator() {
         // If cloned, the iterator will yield the same elements.
         let it = bitflag.iter();
         assert!(it.clone().zip(it).all(|(a, b)| a == b));
+        // The ExactLenIterator implementation should always yield the
+        // correct remaining length.
+        let mut it = bitflag.iter();
+        for rest in (0..=expected.len()).rev() {
+            assert_eq!(it.len(), rest);
+            assert_eq!(it.size_hint(), (rest, Some(rest)));
+            it.next();
+        }
     }
 }