com.wallstop-studios.unity-helpers 2.0.0-rc46 → 2.0.0-rc47

package/Runtime/Core/Extension/EnumExtensions.cs

@@ -0,0 +1,37 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    public static class EnumExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        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;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe 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
+            {
+                1 => *(byte*)&value,
+                2 => *(ushort*)&value,
+                4 => *(uint*)&value,
+                8 => *(ulong*)&value,
+                _ => throw new ArgumentException(
+                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
+                ),
+            };
+        }
+    }
+}

package/Runtime/Core/Extension/EnumExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cb447d880798449cb844f63991aac81b
+timeCreated: 1742771382

package/Tests/Runtime/Extensions/EnumExtensionTests.cs

@@ -0,0 +1,128 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using Core.Extension;
+    using NUnit.Framework;
+    using UnityEngine.TestTools.Constraints;
+    using Is = NUnit.Framework.Is;
+
+    public sealed class EnumExtensionTests
+    {
+        private enum TestEnum
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum TinyTestEnum : byte
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum SmallTestEnum : short
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum BigTestEnum : long
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        [Test]
+        public void HasFlagNoAlloc()
+        {
+            Assert.IsTrue(TestEnum.First.HasFlagNoAlloc(TestEnum.First));
+            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc(TestEnum.Second));
+            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.First));
+            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Second));
+            Assert.IsFalse((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Third));
+            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc((TestEnum.First | TestEnum.Second)));
+        }
+
+        [Test]
+        public void HasFlagNoAllocTiny()
+        {
+            Assert.IsTrue(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First));
+            Assert.IsFalse(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second));
+            Assert.IsTrue(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.First)
+            );
+            Assert.IsTrue(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Third)
+            );
+            Assert.IsFalse(
+                TinyTestEnum.First.HasFlagNoAlloc((TinyTestEnum.First | TinyTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagNoAllocSmall()
+        {
+            Assert.IsTrue(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.First));
+            Assert.IsFalse(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.Second));
+            Assert.IsTrue(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.First)
+            );
+            Assert.IsTrue(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Third)
+            );
+            Assert.IsFalse(
+                SmallTestEnum.First.HasFlagNoAlloc((SmallTestEnum.First | SmallTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagNoAllocBig()
+        {
+            Assert.IsTrue(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First));
+            Assert.IsFalse(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second));
+            Assert.IsTrue(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.First)
+            );
+            Assert.IsTrue(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Third)
+            );
+            Assert.IsFalse(
+                BigTestEnum.First.HasFlagNoAlloc((BigTestEnum.First | BigTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagsNoAllocDoesNotAlloc()
+        {
+            Assert.That(
+                () =>
+                {
+                    TestEnum.First.HasFlagNoAlloc(TestEnum.First);
+                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First);
+                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First);
+
+                    TestEnum.First.HasFlagNoAlloc(TestEnum.Second);
+                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second);
+                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second);
+                },
+                Is.Not.AllocatingGCMemory()
+            );
+        }
+    }
+}

package/Tests/Runtime/Extensions/EnumExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08e6640512474d02bc94651af90a6ffd
+timeCreated: 1742771579

package/package.json

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