From 34aadb450256fde6e896cb8e74a373aa4ce430cd Mon Sep 17 00:00:00 2001
From: Lymia Aluysia <lymia@lymiahugs.com>
Date: Sat, 4 Apr 2020 12:52:03 -0700
Subject: [PATCH] Added FromIterator/Extend operations for iterators of
 EnumSets.

---
 RELEASES.md          |  2 ++
 enumset/src/lib.rs   | 14 ++++++++++++++
 enumset/tests/ops.rs | 23 +++++++++++++++++++----
 3 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/RELEASES.md b/RELEASES.md
index 25201a8..ef8d51c 100644
--- 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 580deba..bde7910 100644
--- 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 aece559..4d536b1 100644
--- 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>) {
-- 
2.44.0