Added FromIterator/Extend operations for iterators of EnumSets.

diff --git a/RELEASES.md b/RELEASES.md
index 25201a87a181621b8a06a83388dca075397018e0..ef8d51ce4e9a88e076fc54a046cc484491c6e020 100644 (file)
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -17,6 +17,8 @@
   panicking when the conversion cannot be done.
 * Added variants of `as_u128`/`from_u128` that truncate unknown bits instead
   of panicking.
+* Implemented `Extend<EnumSet<T>>` and `FromIterator<EnumSet<T>>` for
+  `EnumSet<T>`.
 
 ## Bugfixes
 * Fixed a bug where the procedural macro would fail on enums with a repr

diff --git a/enumset/src/lib.rs b/enumset/src/lib.rs
index 580debab9f1d4f0d0e43c5482a8bda27ead889c6..bde7910bebe0673cfa1ad8de9d8df9e070b602f6 100644 (file)
--- a/enumset/src/lib.rs
+++ b/enumset/src/lib.rs
@@ -636,6 +636,20 @@ impl<T: EnumSetType> FromIterator<T> for EnumSet<T> {
     }
 }
 
+impl<T: EnumSetType> Extend<EnumSet<T>> for EnumSet<T> {
+    fn extend<I: IntoIterator<Item = EnumSet<T>>>(&mut self, iter: I) {
+        iter.into_iter().for_each(|v| { self.insert_all(v); });
+    }
+}
+
+impl<T: EnumSetType> FromIterator<EnumSet<T>> for EnumSet<T> {
+    fn from_iter<I: IntoIterator<Item = EnumSet<T>>>(iter: I) -> Self {
+        let mut set = EnumSet::default();
+        set.extend(iter);
+        set
+    }
+}
+
 /// Creates a EnumSet literal, which can be used in const contexts.
 ///
 /// The syntax used is `enum_set!(Type::A | Type::B | Type::C)`. Each variant must be of the same

diff --git a/enumset/tests/ops.rs b/enumset/tests/ops.rs
index aece559ef9748c028d40124c2a58d1a5acde207b..4d536b190283c5ae265833d377af402eb9348f31 100644 (file)
--- a/enumset/tests/ops.rs
+++ b/enumset/tests/ops.rs
@@ -148,15 +148,14 @@ macro_rules! test_enum {
         }
 
         #[test]
-        fn basic_iter_test() {
+        fn iter_test() {
             let mut set = EnumSet::new();
             set.insert($e::A);
             set.insert($e::B);
-            set.insert($e::C);
-            set.insert($e::E);
+            set.extend($e::C | $e::E);
 
             let mut set_2 = EnumSet::new();
-            let vec: Vec<$e> = set.iter().collect();
+            let vec: Vec<_> = set.iter().collect();
             for val in vec {
                 assert!(!set_2.contains(val));
                 set_2.insert(val);
@@ -169,6 +168,22 @@ macro_rules! test_enum {
                 set_3.insert(val);
             }
             assert_eq!(set, set_3);
+
+            let mut set_4 = EnumSet::new();
+            let vec: EnumSet<_> = set.into_iter().map(EnumSet::only).collect();
+            for val in vec {
+                assert!(!set_4.contains(val));
+                set_4.insert(val);
+            }
+            assert_eq!(set, set_4);
+
+            let mut set_5 = EnumSet::new();
+            let vec: EnumSet<_> = set.iter().collect();
+            for val in vec {
+                assert!(!set_5.contains(val));
+                set_5.insert(val);
+            }
+            assert_eq!(set, set_5);
         }
 
         fn check_iter_size_hint(set: EnumSet<$e>) {