Support pythonic manipulation of managed enums.

Add support for 'len' method, 'in' operator and iteration of enum types.

Author: jhonabreul

src/embed_tests/ClassManagerTests.cs

@@ -1003,6 +1003,59 @@ def call(instance):
         }
 
         #endregion
+
+        public enum TestEnum
+        {
+            FirstEnumValue,
+            SecondEnumValue,
+            ThirdEnumValue
+        }
+
+        [Test]
+        public void EnumPythonOperationsCanBePerformedOnManagedEnum()
+        {
+            using (Py.GIL())
+            {
+                var module = PyModule.FromString("EnumPythonOperationsCanBePerformedOnManagedEnum", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+def get_enum_values():
+    return [x for x in ClassManagerTests.TestEnum]
+
+def count_enum_values():
+    return len(ClassManagerTests.TestEnum)
+
+def is_enum_value_defined(value):
+    return value in ClassManagerTests.TestEnum
+                    ");
+
+                using var pyEnumValues = module.InvokeMethod("get_enum_values");
+                var enumValues = pyEnumValues.As<List<TestEnum>>();
+
+                var expectedEnumValues = Enum.GetValues<TestEnum>();
+                CollectionAssert.AreEquivalent(expectedEnumValues, enumValues);
+
+                using var pyEnumCount = module.InvokeMethod("count_enum_values");
+                var enumCount = pyEnumCount.As<int>();
+                Assert.AreEqual(expectedEnumValues.Length, enumCount);
+
+                var validEnumValues = expectedEnumValues
+                    .SelectMany(x => new object[] { x, (int)x, Enum.GetName(x.GetType(), x) })
+                    .Select(x => (x, true));
+                var invalidEnumValues = new object[] { 5, "INVALID_ENUM_VALUE" }.Select(x => (x, false));
+
+                foreach (var (enumValue, isValid) in validEnumValues.Concat(invalidEnumValues))
+                {
+                    using var pyEnumValue = enumValue.ToPython();
+                    using var pyIsDefined = module.InvokeMethod("is_enum_value_defined", pyEnumValue);
+                    var isDefined = pyIsDefined.As<bool>();
+                    Assert.AreEqual(isValid, isDefined, $"Failed for {enumValue} ({enumValue.GetType()})");
+                }
+            }
+        }
     }
 
     public class NestedTestParent

src/runtime/Types/MetaType.cs

@@ -359,5 +359,64 @@ public static NewReference __subclasscheck__(BorrowedReference tp, BorrowedRefer
         {
             return DoInstanceCheck(tp, args, true);
         }
+
+        /// <summary>
+        /// Standard iteration support Enums. This allows natural interation
+        /// over the available values an Enum defines.
+        /// </summary>
+        public static NewReference tp_iter(BorrowedReference tp)
+        {
+            var type = CheckAndGetEnumType(tp);
+            var values = Enum.GetValues(type);
+            return new Iterator(values.GetEnumerator(), type).Alloc();
+        }
+
+        /// <summary>
+        /// Implements __len__ for Enum types.
+        /// </summary>
+        public static int mp_length(BorrowedReference tp)
+        {
+            var type = CheckAndGetEnumType(tp);
+            return Enum.GetValues(type).Length;
+        }
+
+        /// <summary>
+        /// Implements __contains__ for Enum types.
+        /// </summary>
+        public static int sq_contains(BorrowedReference tp, BorrowedReference v)
+        {
+            var type = CheckAndGetEnumType(tp);
+
+            if (!Converter.ToManaged(v, type, out var enumValue, false) &&
+                !Converter.ToManaged(v, typeof(int), out enumValue, false) &&
+                !Converter.ToManaged(v, typeof(string), out enumValue, false))
+            {
+                Exceptions.SetError(Exceptions.TypeError,
+                    $"invalid parameter type for sq_contains: should be {Converter.GetTypeByAlias(v)}, found {type}");
+            }
+            return Enum.IsDefined(type, enumValue) ? 1 : 0;
+        }
+
+        private static Type CheckAndGetEnumType(BorrowedReference tp)
+        {
+            var cb = GetManagedObject(tp) as ClassBase;
+            if (cb == null)
+            {
+                Exceptions.SetError(Exceptions.TypeError, "invalid object");
+            }
+
+            if (!cb.type.Valid)
+            {
+                Exceptions.SetError(Exceptions.TypeError, "invalid type");
+            }
+
+            var type = cb.type.Value;
+            if (!type.IsEnum)
+            {
+                Exceptions.SetError(Exceptions.TypeError, "uniterable object");
+            }
+
+            return type;
+        }
     }
 }