com.wallstop-studios.unity-helpers 2.0.0-rc80.4 → 2.0.0-rc80.5

package/Runtime/Core/Extension/EnumExtensions.cs

@@ -12,142 +12,60 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
     public static class EnumNameCache<T>
         where T : struct, Enum
     {
-        private const int MaxDenseRange = 1024;
-
-        private static readonly bool UseDensePacking;
-        private static readonly int Min;
-        private static readonly string[] DenseNames;
-        private static readonly Dictionary<int, string> SparseNames;
+        private static readonly Dictionary<T, string> Names;
 
         static EnumNameCache()
         {
-            T[] values = Enum.GetValues(typeof(T)).Cast<T>().ToArray();
-            int[] intValues = values.Select(v => Unsafe.As<T, int>(ref v)).ToArray();
-            int min = intValues.Min();
-            int max = intValues.Max();
-            int range = max - min + 1;
-
-            if (range <= MaxDenseRange)
-            {
-                UseDensePacking = true;
-                Min = min;
-                DenseNames = new string[range];
-
-                for (int i = 0; i < values.Length; i++)
-                {
-                    int key = intValues[i] - min;
-                    T value = values[i];
-                    DenseNames[key] = value.ToString("G");
-                }
-            }
-            else
+            T[] values = Enum.GetValues(typeof(T)).OfType<T>().ToArray();
+            Names = new Dictionary<T, string>(values.Length);
+            for (int i = 0; i < values.Length; i++)
             {
-                UseDensePacking = false;
-                SparseNames = new Dictionary<int, string>();
-                for (int i = 0; i < values.Length; i++)
-                {
-                    int key = Unsafe.As<T, int>(ref values[i]);
-                    T value = values[i];
-                    string name = value.ToString("G");
-                    SparseNames.TryAdd(key, name);
-                }
+                T value = values[i];
+                string name = value.ToString("G");
+                Names.TryAdd(value, name);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static string ToCachedName(T value)
         {
-            int key = Unsafe.As<T, int>(ref value);
-            if (UseDensePacking)
+            if (Names.TryGetValue(value, out string name))
             {
-                int idx = key - Min;
-                if ((uint)idx < (uint)DenseNames!.Length)
-                {
-                    return DenseNames[idx];
-                }
-            }
-            else
-            {
-                if (SparseNames!.TryGetValue(key, out string name))
-                {
-                    return name;
-                }
+                return name;
             }
 
-            return value.ToString();
+            return value.ToString("G");
         }
     }
 
     public static class EnumDisplayNameCache<T>
         where T : struct, Enum
     {
-        private const int MaxDenseRange = 1024;
-
-        private static readonly bool UseDensePacking;
-        private static readonly int Min;
-        private static readonly string[] DenseNames;
-        private static readonly Dictionary<int, string> SparseNames;
+        private static readonly Dictionary<T, string> Names;
 
         static EnumDisplayNameCache()
         {
             Type type = typeof(T);
             FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
-            T[] values = fields.Select(f => (T)f.GetValue(null)).ToArray();
-            int[] intValues = values.Select(v => Unsafe.As<T, int>(ref v)).ToArray();
-            int min = intValues.Min();
-            int max = intValues.Max();
-            int range = max - min + 1;
+            Names = new Dictionary<T, string>(fields.Length);
 
-            if (range <= MaxDenseRange)
+            for (int i = 0; i < fields.Length; i++)
             {
-                UseDensePacking = true;
-                Min = min;
-                DenseNames = new string[range];
-
-                for (int i = 0; i < fields.Length; i++)
-                {
-                    int key = intValues[i] - min;
-                    FieldInfo field = fields[i];
-                    string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
-                        ? displayName.DisplayName
-                        : field.Name;
-                    DenseNames[key] = name;
-                }
-            }
-            else
-            {
-                UseDensePacking = false;
-                SparseNames = new Dictionary<int, string>(fields.Length);
-                for (int i = 0; i < fields.Length; i++)
-                {
-                    int key = Unsafe.As<T, int>(ref values[i]);
-                    FieldInfo field = fields[i];
-                    string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
-                        ? displayName.DisplayName
-                        : field.Name;
-                    SparseNames.TryAdd(key, name);
-                }
+                FieldInfo field = fields[i];
+                string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
+                    ? displayName.DisplayName
+                    : field.Name;
+                T value = (T)field.GetValue(null);
+                Names.TryAdd(value, name);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static string ToDisplayName(T value)
         {
-            int key = Unsafe.As<T, int>(ref value);
-            if (UseDensePacking)
+            if (Names.TryGetValue(value, out string name))
             {
-                int idx = key - Min;
-                if ((uint)idx < (uint)DenseNames!.Length)
-                {
-                    return DenseNames[idx];
-                }
-            }
-            else
-            {
-                if (SparseNames!.TryGetValue(key, out string name))
-                {
-                    return name;
-                }
+                return name;
             }
 
             return value.ToString();
@@ -160,9 +78,15 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
         public static bool HasFlagNoAlloc<T>(this T value, T flag)
             where T : unmanaged, Enum
         {
-            ulong valueUnderlying = GetUInt64(value);
-            ulong flagUnderlying = GetUInt64(flag);
-            return (valueUnderlying & flagUnderlying) == flagUnderlying;
+            ulong? valueUnderlying = GetUInt64(value);
+            ulong? flagUnderlying = GetUInt64(flag);
+            if (valueUnderlying == null || flagUnderlying == null)
+            {
+                // Fallback for unsupported enum sizes
+                return value.HasFlag(flag);
+            }
+
+            return (valueUnderlying.Value & flagUnderlying.Value) == flagUnderlying.Value;
         }
 
         public static string ToDisplayName<T>(this T value)
@@ -190,23 +114,24 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe ulong GetUInt64<T>(T value)
+        private static ulong? GetUInt64<T>(T value)
             where T : unmanaged
         {
-            /*
-                Works because T is constrained to unmanaged, so it's safe to reinterpret
-                All enums are value types and have a fixed size
-             */
-            return sizeof(T) switch
+            try
             {
-                1 => *(byte*)&value,
-                2 => *(ushort*)&value,
-                4 => *(uint*)&value,
-                8 => *(ulong*)&value,
-                _ => throw new ArgumentException(
-                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
-                ),
-            };
+                return Unsafe.SizeOf<T>() switch
+                {
+                    1 => Unsafe.As<T, byte>(ref value),
+                    2 => Unsafe.As<T, ushort>(ref value),
+                    4 => Unsafe.As<T, uint>(ref value),
+                    8 => Unsafe.As<T, ulong>(ref value),
+                    _ => null,
+                };
+            }
+            catch
+            {
+                return null;
+            }
         }
     }
 }

package/Tests/Runtime/Extensions/EnumExtensionTests.cs

@@ -2,6 +2,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
 {
     using NUnit.Framework;
     using UnityEngine.TestTools.Constraints;
+    using WallstopStudios.UnityHelpers.Core.Attributes;
     using WallstopStudios.UnityHelpers.Core.Extension;
     using Is = NUnit.Framework.Is;
 
@@ -26,8 +27,14 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
         private enum SmallTestEnum : short
         {
             None = 0,
+
+            [EnumDisplayName("TestFirst")]
             First = 1 << 0,
+
+            [EnumDisplayName("TestSecond")]
             Second = 1 << 1,
+
+            [EnumDisplayName("TestThird")]
             Third = 1 << 2,
         }
 
@@ -39,6 +46,24 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             Third = 1 << 2,
         }
 
+        [Test]
+        public void DisplayName()
+        {
+            Assert.AreEqual("None", SmallTestEnum.None.ToDisplayName());
+            Assert.AreEqual("TestFirst", SmallTestEnum.First.ToDisplayName());
+            Assert.AreEqual("TestSecond", SmallTestEnum.Second.ToDisplayName());
+            Assert.AreEqual("TestThird", SmallTestEnum.Third.ToDisplayName());
+        }
+
+        [Test]
+        public void CachedName()
+        {
+            Assert.AreEqual("None", SmallTestEnum.None.ToCachedName());
+            Assert.AreEqual("First", SmallTestEnum.First.ToCachedName());
+            Assert.AreEqual("Second", SmallTestEnum.Second.ToCachedName());
+            Assert.AreEqual("Third", SmallTestEnum.Third.ToCachedName());
+        }
+
         [Test]
         public void HasFlagNoAlloc()
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc80.4",
+  "version": "2.0.0-rc80.5",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -56,5 +56,6 @@
 
 
 
+