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

package/Runtime/Core/Extension/DictionaryExtensions.cs

@@ -125,7 +125,11 @@
         {
             if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
-                return concurrentDictionary.AddOrUpdate(key, creator, (_, existing) => existing);
+                return concurrentDictionary.AddOrUpdate(
+                    key,
+                    creator,
+                    (_, existingValue) => existingValue
+                );
             }
 
             if (dictionary.TryGetValue(key, out V existing))
@@ -206,6 +210,14 @@
             return new Dictionary<K, V>(dictionary);
         }
 
+        public static Dictionary<K, V> ToDictionary<K, V>(
+            this IReadOnlyDictionary<K, V> dictionary,
+            IEqualityComparer<K> comparer
+        )
+        {
+            return new Dictionary<K, V>(dictionary, comparer);
+        }
+
         public static Dictionary<K, V> ToDictionary<K, V>(
             this IEnumerable<KeyValuePair<K, V>> prettyMuchADictionary
         )
@@ -213,6 +225,14 @@
             return prettyMuchADictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
         }
 
+        public static Dictionary<K, V> ToDictionary<K, V>(
+            this IEnumerable<KeyValuePair<K, V>> prettyMuchADictionary,
+            IEqualityComparer<K> comparer
+        )
+        {
+            return prettyMuchADictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, comparer);
+        }
+
         public static Dictionary<K, V> ToDictionary<K, V>(
             this IEnumerable<(K, V)> prettyMuchADictionary
         )
@@ -220,6 +240,14 @@
             return prettyMuchADictionary.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2);
         }
 
+        public static Dictionary<K, V> ToDictionary<K, V>(
+            this IEnumerable<(K, V)> prettyMuchADictionary,
+            IEqualityComparer<K> comparer
+        )
+        {
+            return prettyMuchADictionary.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2, comparer);
+        }
+
         public static bool ContentEquals<K, V>(
             this IReadOnlyDictionary<K, V> dictionary,
             IReadOnlyDictionary<K, V> other

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/Runtime/Core/Threading/SingleThreadedThreadPool.cs

@@ -52,10 +52,7 @@
                 return;
             }
 
-            while (Interlocked.CompareExchange(ref _active, 0, _active) != 0)
-            {
-                // Spin
-            }
+            Interlocked.Exchange(ref _active, 0);
 
             if (disposing)
             {

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-rc48",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},