From 62e107b5203f18b90308c4e3876b7d57a885bc31 Mon Sep 17 00:00:00 2001
From: Jack Kanarish <jack.kanarish@wedoresi.com>
Date: Tue, 3 Apr 2018 12:28:58 -0400
Subject: [PATCH 1/2] feat: Added GetAllFlagCombinationsExceptNone method to
 EnumUtils

---
 ICD.Common.Utils/EnumUtils.cs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/ICD.Common.Utils/EnumUtils.cs b/ICD.Common.Utils/EnumUtils.cs
index b0a7d70..03b6b90 100644
--- a/ICD.Common.Utils/EnumUtils.cs
+++ b/ICD.Common.Utils/EnumUtils.cs
@@ -305,6 +305,25 @@ namespace ICD.Common.Utils
 			return GetFlags(value).Except(none);
 		}
 
+		/// <summary>
+		/// Gets all of the flag combinations on the given flag enum value.
+		/// 
+		/// IE: If you have an enum type with flags{a, b, c}, and you pass this method {a|b},
+		/// It will return {a, b, a|b}
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="value"></param>
+		/// <returns></returns>
+		public static IEnumerable<T> GetAllFlagCombinationsExceptNone<T>(T value)
+		{
+			if (!IsEnum(value))
+				// ReSharper disable once CompareNonConstrainedGenericWithNull
+				throw new ArgumentException(string.Format("{0} is not an enum", value == null ? "NULL" : value.GetType().Name), "value");
+
+			int maxEnumValue = (GetValues<T>().Max(v => (int)(object)v) * 2) -1 ;
+			return Enumerable.Range(1, maxEnumValue).Cast<T>().Where(v => HasFlags(value, v));
+		}
+
 		/// <summary>
 		/// Gets an enum value of the given type with every flag set.
 		/// </summary>

From 01ae0106fe0702c9b2e0789ee45d0d308186758b Mon Sep 17 00:00:00 2001
From: Jack Kanarish <jack.kanarish@wedoresi.com>
Date: Tue, 3 Apr 2018 12:29:59 -0400
Subject: [PATCH 2/2] test: add test for GetAllFlagCombinationsExceptNone
 method. added a value to eTestFlagsEnum, fixed tests broken by that change

---
 ICD.Common.Utils.Tests/EnumUtilsTest.cs | 36 ++++++++++++++++++++++---
 1 file changed, 32 insertions(+), 4 deletions(-)

diff --git a/ICD.Common.Utils.Tests/EnumUtilsTest.cs b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
index 35a4724..f1d84f1 100644
--- a/ICD.Common.Utils.Tests/EnumUtilsTest.cs
+++ b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
@@ -21,7 +21,8 @@ namespace ICD.Common.Utils.Tests
 			None = 0,
 			A = 1,
 			B = 2,
-			C = 4
+			C = 4,
+			D = 32
 		}
 		
 		[Test]
@@ -160,11 +161,12 @@ namespace ICD.Common.Utils.Tests
 			eTestFlagsEnum a = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
 			eTestFlagsEnum[] aValues = EnumUtils.GetFlags(a).ToArray();
 
-			Assert.AreEqual(4, aValues.Length);
+			Assert.AreEqual(5, aValues.Length);
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.None));
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A));
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B));
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.D));
 		}
 
 		[Test]
@@ -173,18 +175,44 @@ namespace ICD.Common.Utils.Tests
 			eTestFlagsEnum a = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
 			eTestFlagsEnum[] aValues = EnumUtils.GetFlagsExceptNone(a).ToArray();
 
-			Assert.AreEqual(3, aValues.Length);
+			Assert.AreEqual(4, aValues.Length);
 			Assert.IsFalse(aValues.Contains(eTestFlagsEnum.None));
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A));
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B));
 			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.D));
+		}
+
+	    [Test]
+	    public void GetAllFlagCombinationsExceptNoneGenericTest()
+	    {
+		    eTestFlagsEnum a = eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D;
+		    eTestFlagsEnum[] aValues = EnumUtils.GetAllFlagCombinationsExceptNone(a).ToArray();
+
+			Assert.AreEqual(15, aValues.Length);
+			Assert.IsFalse(aValues.Contains(eTestFlagsEnum.None));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.C));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B | eTestFlagsEnum.C));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B | eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C | eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.C | eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D));
+			Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D));
 		}
 
 		[Test]
 		public void GetFlagsAllValueGenericTest()
 		{
 			eTestFlagsEnum value = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
-			Assert.AreEqual(eTestFlagsEnum.None | eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C, value);
+			Assert.AreEqual(eTestFlagsEnum.None | eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D, value);
 		}
 
 		[Test]