Added a new class, EnumHelper, which provides an implementation of Enum.GetValues() for the Xbox 360 and the GetHighestValue() and GetLowestValue() methods which can be useful if you want to create a flags array (eg. using the BitArray class) for an enumeration not declared with the [Flags] attribute or a flags enumeration not fitting within an integer or long; wrote unit tests for the new EnumHelper class, test coverage remains at 100.0%

git-svn-id: file:///srv/devel/repo-conversion/nusu@186 d2e56fa2-650e-0410-a79f-9358c0239efd

Nuclex.Support (Xbox 360).csproj

@@ -134,6 +134,10 @@
       <DependentUpon>ReverseComparer.cs</DependentUpon>
     </Compile>
     <Compile Include="Source\AffineThreadPool.cs" />
+    <Compile Include="Source\EnumHelper.cs" />
+    <Compile Include="Source\EnumHelper.Test.cs">
+      <DependentUpon>EnumHelper.cs</DependentUpon>
+    </Compile>
     <Compile Include="Source\Plugins\PrototypeFactory.cs" />
     <Compile Include="Source\Plugins\PrototypeFactory.Test.cs">
       <DependentUpon>PrototypeFactory.cs</DependentUpon>

Nuclex.Support.csproj

@@ -120,6 +120,10 @@
       <DependentUpon>ReverseComparer.cs</DependentUpon>
     </Compile>
     <Compile Include="Source\AffineThreadPool.cs" />
+    <Compile Include="Source\EnumHelper.cs" />
+    <Compile Include="Source\EnumHelper.Test.cs">
+      <DependentUpon>EnumHelper.cs</DependentUpon>
+    </Compile>
     <Compile Include="Source\Plugins\PrototypeFactory.cs" />
     <Compile Include="Source\Plugins\PrototypeFactory.Test.cs">
       <DependentUpon>PrototypeFactory.cs</DependentUpon>

Source/EnumHelper.Test.cs

@@ -0,0 +1,149 @@
+#region CPL License
+/*
+Nuclex Framework
+Copyright (C) 2002-2009 Nuclex Development Labs
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the IBM Common Public License as
+published by the IBM Corporation; either version 1.0 of the
+License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+IBM Common Public License for more details.
+
+You should have received a copy of the IBM Common Public
+License along with this library
+*/
+#endregion
+
+#if UNITTEST
+
+using System;
+using System.IO;
+
+using NUnit.Framework;
+
+namespace Nuclex.Support {
+
+  /// <summary>Unit Test for the enumeration helper class</summary>
+  [TestFixture]
+  public class EnumHelperTest {
+
+    #region enum TestEnumeration
+
+    /// <summary>An enumeration used for unit testing</summary>
+    internal enum TestEnumeration {
+      /// <summary>First arbitrary enumeration value</summary>
+      One = -2,
+      /// <summary>Third arbitrary enumeration value</summary>
+      Three = 33,
+      /// <summary>Second arbitrary enumeration value</summary>
+      Two = 23
+    }
+
+    #endregion // enum TestEnumeration
+
+    #region enum EmptyEnumeration
+
+    internal enum EmptyEnumeration { }
+
+    #endregion // enum EmptyEnumeration
+
+    /// <summary>
+    ///   Verifies that the enum helper can list the members of an enumeration
+    ///   manually (as it needs to be done on the XBox 360)
+    /// </summary>
+    [Test]
+    public void TestGetValuesXbox360() {
+      CollectionAssert.AreEquivalent(
+        new TestEnumeration[] {
+          TestEnumeration.One, TestEnumeration.Two, TestEnumeration.Three
+        },
+        EnumHelper.GetValuesXbox360<TestEnumeration>()
+      );
+    }
+
+    /// <summary>
+    ///   Verifies that the enum helper can list the members of an enumeration
+    /// </summary>
+    [Test]
+    public void TestGetValues() {
+      CollectionAssert.AreEquivalent(
+        new TestEnumeration[] {
+          TestEnumeration.One, TestEnumeration.Two, TestEnumeration.Three
+        },
+        EnumHelper.GetValues<TestEnumeration>()
+      );
+    }
+
+    /// <summary>
+    ///   Verifies that the enum helper can locate the highest value in an enumeration
+    /// </summary>
+    [Test]
+    public void TestGetHighestValue() {
+      Assert.AreEqual(
+        TestEnumeration.Three, EnumHelper.GetHighestValue<TestEnumeration>()
+      );
+    }
+
+    /// <summary>
+    ///   Verifies that the enum helper can locate the lowest value in an enumeration
+    /// </summary>
+    [Test]
+    public void TestGetLowestValue() {
+      Assert.AreEqual(
+        TestEnumeration.One, EnumHelper.GetLowestValue<TestEnumeration>()
+      );
+    }
+
+    /// <summary>
+    ///   Tests whether an exception is thrown if the GetValuesXbox360() method is
+    ///   used on a non-enumeration type
+    /// </summary>
+    [Test]
+    public void TestThrowOnNonEnumTypeXbox360() {
+      Assert.Throws<ArgumentException>(
+        delegate() { EnumHelper.GetValuesXbox360<int>(); }
+      );
+    }
+
+    /// <summary>
+    ///   Tests whether an exception is thrown if the GetValues() method is used on
+    ///   a non-enumeration type
+    /// </summary>
+    [Test]
+    public void TestThrowOnNonEnumType() {
+      Assert.Throws<ArgumentException>(
+        delegate() { EnumHelper.GetValues<int>(); }
+      );
+    }
+
+    /// <summary>
+    ///   Verifies that the default value for an enumeration is returned if
+    ///   the GetLowestValue() method is used on an empty enumeration
+    /// </summary>
+    [Test]
+    public void TestLowestValueInEmptyEnumeration() {
+      Assert.AreEqual(
+        default(EmptyEnumeration), EnumHelper.GetLowestValue<EmptyEnumeration>()
+      );
+    }
+
+    /// <summary>
+    ///   Verifies that the default value for an enumeration is returned if
+    ///   the GetHighestValue() method is used on an empty enumeration
+    /// </summary>
+    [Test]
+    public void TestHighestValueInEmptyEnumeration() {
+      Assert.AreEqual(
+        default(EmptyEnumeration), EnumHelper.GetHighestValue<EmptyEnumeration>()
+      );
+    }
+
+  }
+
+} // namespace Nuclex.Support
+
+#endif // UNITTEST

Source/EnumHelper.cs

@@ -0,0 +1,126 @@
+#region CPL License
+/*
+Nuclex Framework
+Copyright (C) 2002-2009 Nuclex Development Labs
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the IBM Common Public License as
+published by the IBM Corporation; either version 1.0 of the
+License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+IBM Common Public License for more details.
+
+You should have received a copy of the IBM Common Public
+License along with this library
+*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+
+namespace Nuclex.Support {
+
+  /// <summary>Helper methods for enumerations</summary>
+  public static class EnumHelper {
+
+    /// <summary>Returns the highest value encountered in an enumeration</summary>
+    /// <typeparam name="EnumType">
+    ///   Enumeration of which the highest value will be returned
+    /// </typeparam>
+    /// <returns>The highest value in the enumeration</returns>
+    public static EnumType GetHighestValue<EnumType>() where EnumType : IComparable {
+      EnumType[] values = GetValues<EnumType>();
+
+      // If the enumeration is empty, return nothing
+      if(values.Length == 0) {
+        return default(EnumType);
+      }
+
+      // Look for the highest value in the enumeration. We initialize the highest value
+      // to the first enumeration value so we don't have to use some arbitrary starting
+      // value which might actually appear in the enumeration.
+      EnumType highestValue = values[0];
+      for(int index = 1; index < values.Length; ++index) {
+        if(values[index].CompareTo(highestValue) > 0) {
+          highestValue = values[index];
+        }
+      }
+
+      return highestValue;
+    }
+
+    /// <summary>Returns the lowest value encountered in an enumeration</summary>
+    /// <typeparam name="EnumType">
+    ///   Enumeration of which the lowest value will be returned
+    /// </typeparam>
+    /// <returns>The lowest value in the enumeration</returns>
+    public static EnumType GetLowestValue<EnumType>() where EnumType : IComparable {
+      EnumType[] values = GetValues<EnumType>();
+
+      // If the enumeration is empty, return nothing
+      if(values.Length == 0) {
+        return default(EnumType);
+      }
+
+      // Look for the lowest value in the enumeration. We initialize the lowest value
+      // to the first enumeration value so we don't have to use some arbitrary starting
+      // value which might actually appear in the enumeration.
+      EnumType lowest = values[0];
+      for(int index = 1; index < values.Length; ++index) {
+        if(values[index].CompareTo(lowest) < 0) {
+          lowest = values[index];
+        }
+      }
+
+      return lowest;
+    }
+
+    /// <summary>Retrieves a list of all values contained in an enumeration</summary>
+    /// <typeparam name="EnumType">
+    ///   Type of the enumeration whose values will be returned
+    /// </typeparam>
+    /// <returns>All values contained in the specified enumeration</returns>
+    public static EnumType[] GetValues<EnumType>() {
+#if XBOX360
+      return GetValuesXbox360<EnumType>();
+#else
+      return (EnumType[])Enum.GetValues(typeof(EnumType));
+#endif
+    }
+
+    /// <summary>Retrieves a list of all values contained in an enumeration</summary>
+    /// <typeparam name="EnumType">
+    ///   Type of the enumeration whose values will be returned
+    /// </typeparam>
+    /// <returns>All values contained in the specified enumeration</returns>
+    internal static EnumType[] GetValuesXbox360<EnumType>() {
+      Type enumType = typeof(EnumType);
+      if(!enumType.IsEnum) {
+        throw new ArgumentException(
+          "The provided type needs to be an enumeration", "EnumType"
+        );
+      }
+      
+      // Use reflection to get all fields in the enumeration      
+      FieldInfo[] fieldInfos = enumType.GetFields(
+        BindingFlags.Public | BindingFlags.Static
+      );
+
+      // Create an array to hold the enumeration value and copy them over from
+      // the fields we just retrieved
+      EnumType[] values = new EnumType[fieldInfos.Length];
+      for(int index = 0; index < fieldInfos.Length; ++index) {
+        values[index] = (EnumType)fieldInfos[index].GetValue(null);
+      }
+
+      return values;
+    }
+
+  }
+
+} // namespace Nuclex.Support