com.wallstop-studios.unity-helpers 2.0.0-rc80.6 → 2.0.0-rc80.8

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -1013,6 +1013,33 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
             }
         }
 
+        public static Action<T> BuildParameterlessInstanceMethodIfExists<T>(string methodName)
+        {
+            try
+            {
+                Type type = typeof(T);
+                foreach (
+                    MethodInfo method in type.GetMethods(
+                        BindingFlags.Instance | BindingFlags.Public
+                    )
+                )
+                {
+                    if (
+                        string.Equals(method.Name, methodName, StringComparison.Ordinal)
+                        && method.GetParameters().Length == 0
+                    )
+                    {
+                        return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), method);
+                    }
+                }
+            }
+            catch
+            {
+                // Swallow
+            }
+            return null;
+        }
+
         public static bool HasAttributeSafe(
             ICustomAttributeProvider provider,
             Type attributeType,

package/Runtime/Utils/Buffers.cs

@@ -1,13 +1,13 @@
 namespace WallstopStudios.UnityHelpers.Utils
 {
     using System;
-    using System.Collections.Concurrent;
     using System.Collections.Generic;
-    using System.Reflection;
     using System.Text;
-    using System.Threading;
     using UnityEngine;
-    using WallstopStudios.UnityHelpers.Core.Helper;
+#if !SINGLE_THREADED
+    using System.Threading;
+    using System.Collections.Concurrent;
+#endif
 
     public static class Buffers
     {
@@ -38,66 +38,107 @@ namespace WallstopStudios.UnityHelpers.Utils
         public static readonly Stack<T> Stack = new();
     }
 
-    public static class WallstopGenericPool<T>
-        where T : new()
+#if SINGLE_THREADED
+    public sealed class WallstopGenericPool<T> : IDisposable
     {
-        public static Action<T> clearAction;
+        private readonly Func<T> _producer;
+        private readonly Action<T> _onGet;
+        private readonly Action<T> _onRelease;
+        private readonly Action<T> _onDispose;
 
-        private static readonly List<T> _pool = new();
-        private static readonly Action<T> _onDispose = Release;
+        private readonly Stack<T> _pool = new();
 
-        static WallstopGenericPool()
+        public WallstopGenericPool(
+            Func<T> producer,
+            Action<T> onGet = null,
+            Action<T> onRelease = null,
+            Action<T> onDisposal = null
+        )
         {
-            clearAction = GetClearAction();
+            _producer = producer ?? throw new ArgumentNullException(nameof(producer));
+            _onGet = onGet;
+            _onRelease = onRelease ?? (_ => { });
+            _onRelease += _pool.Push;
+            _onDispose = onDisposal;
         }
 
-        public static PooledResource<T> Get()
+        public PooledResource<T> Get()
         {
-            if (_pool.Count == 0)
+            if (!_pool.TryPop(out T value))
             {
-                return new PooledResource<T>(new T(), _onDispose);
+                value = _producer();
             }
 
-            int lastIndex = _pool.Count - 1;
-            T instance = _pool[lastIndex];
-            _pool.RemoveAt(lastIndex);
-            return new PooledResource<T>(instance, _onDispose);
+            _onGet?.Invoke(value);
+            return new PooledResource<T>(value, _onRelease);
         }
 
-        private static Action<T> GetClearAction()
+        public void Dispose()
         {
-            try
+            if (_onDispose == null)
             {
-                Type type = typeof(T);
-                foreach (
-                    MethodInfo method in type.GetMethods(
-                        BindingFlags.Instance | BindingFlags.Public
-                    )
-                )
-                {
-                    if (
-                        string.Equals(method.Name, "Clear", StringComparison.Ordinal)
-                        && method.GetParameters().Length == 0
-                    )
-                    {
-                        return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), method);
-                    }
-                }
+                _pool.Clear();
+                return;
             }
-            catch
+
+            while (_pool.TryPop(out T value))
             {
-                // Swallow
+                _onDispose(value);
             }
-            return null;
         }
+    }
+#else
+    public sealed class WallstopGenericPool<T> : IDisposable
+    {
+        private readonly Func<T> _producer;
+        private readonly Action<T> _onGet;
+        private readonly Action<T> _onRelease;
+        private readonly Action<T> _onDispose;
+
+        private readonly ConcurrentStack<T> _pool = new();
 
-        private static void Release(T resource)
+        public WallstopGenericPool(
+            Func<T> producer,
+            Action<T> onGet = null,
+            Action<T> onRelease = null,
+            Action<T> onDisposal = null
+        )
         {
-            clearAction?.Invoke(resource);
-            _pool.Add(resource);
+            _producer = producer ?? throw new ArgumentNullException(nameof(producer));
+            _onGet = onGet;
+            _onRelease = onRelease ?? (_ => { });
+            _onRelease += _pool.Push;
+            _onDispose = onDisposal;
+        }
+
+        public PooledResource<T> Get()
+        {
+            if (!_pool.TryPop(out T value))
+            {
+                value = _producer();
+            }
+
+            _onGet?.Invoke(value);
+            return new PooledResource<T>(value, _onRelease);
+        }
+
+        public void Dispose()
+        {
+            if (_onDispose == null)
+            {
+                _pool.Clear();
+                return;
+            }
+
+            while (_pool.TryPop(out T value))
+            {
+                _onDispose(value);
+            }
         }
     }
+#endif
 
+#if SINGLE_THREADED
     public static class WallstopArrayPool<T>
     {
         private static readonly Dictionary<int, List<T[]>> _pool = new();
@@ -150,12 +191,54 @@ namespace WallstopStudios.UnityHelpers.Utils
             pool.Add(resource);
         }
     }
+#else
+    public static class WallstopArrayPool<T>
+    {
+        private static readonly ConcurrentDictionary<int, ConcurrentStack<T[]>> _pool = new();
+        private static readonly Action<T[]> _onRelease = Release;
+
+        public static PooledResource<T[]> Get(int size)
+        {
+            switch (size)
+            {
+                case < 0:
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(size),
+                        size,
+                        "Must be non-negative."
+                    );
+                }
+                case 0:
+                {
+                    return new PooledResource<T[]>(Array.Empty<T>(), _ => { });
+                }
+            }
+
+            ConcurrentStack<T[]> result = _pool.GetOrAdd(size, _ => new ConcurrentStack<T[]>());
+            if (!result.TryPop(out T[] array))
+            {
+                array = new T[size];
+            }
+
+            return new PooledResource<T[]>(array, _onRelease);
+        }
+
+        private static void Release(T[] resource)
+        {
+            int length = resource.Length;
+            Array.Clear(resource, 0, length);
+            ConcurrentStack<T[]> result = _pool.GetOrAdd(length, _ => new ConcurrentStack<T[]>());
+            result.Push(resource);
+        }
+    }
+#endif
 
 #if SINGLE_THREADED
     public static class WallstopFastArrayPool<T>
     {
-        private static readonly List<List<T[]>> _pool = new();
-        private static readonly Action<T[]> _onDispose = Release;
+        private static readonly List<Stack<T[]>> _pool = new();
+        private static readonly Action<T[]> _onRelease = Release;
 
         public static PooledResource<T[]> Get(int size)
         {
@@ -180,36 +263,32 @@ namespace WallstopStudios.UnityHelpers.Utils
                 _pool.Add(null);
             }
 
-            List<T[]> pool = _pool[size];
+            Stack<T[]> pool = _pool[size];
             if (pool == null)
             {
-                pool = new List<T[]>();
+                pool = new Stack<T[]>();
                 _pool[size] = pool;
             }
 
-            if (pool.Count == 0)
+            if (!pool.TryPop(out T[] instance))
             {
-                return new PooledResource<T[]>(new T[size], _onDispose);
+                instance = new T[size];
             }
 
-            int lastIndex = pool.Count - 1;
-            T[] instance = pool[lastIndex];
-            pool.RemoveAt(lastIndex);
-            return new PooledResource<T[]>(instance, _onDispose);
+            return new PooledResource<T[]>(instance, _onRelease);
         }
 
         private static void Release(T[] resource)
         {
-            _pool[resource.Length].Add(resource);
+            _pool[resource.Length].Push(resource);
         }
     }
 #else
-
     public static class WallstopFastArrayPool<T>
     {
         private static readonly ReaderWriterLockSlim _lock = new();
         private static readonly List<ConcurrentStack<T[]>> _pool = new();
-        private static readonly Action<T[]> _onDispose = Release;
+        private static readonly Action<T[]> _onRelease = Release;
 
         public static PooledResource<T[]> Get(int size)
         {
@@ -331,11 +410,12 @@ namespace WallstopStudios.UnityHelpers.Utils
                 }
             }
 
-            if (pool.TryPop(out T[] instance))
+            if (!pool.TryPop(out T[] instance))
             {
-                return new PooledResource<T[]>(instance, _onDispose);
+                instance = new T[size];
             }
-            return new PooledResource<T[]>(new T[size], _onDispose);
+
+            return new PooledResource<T[]>(instance, _onRelease);
         }
 
         private static void Release(T[] resource)

package/Tests/Runtime/Utils/BuffersTests.cs

@@ -16,12 +16,17 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
 
     public sealed class BuffersTests
     {
+        private readonly WallstopGenericPool<List<int>> _intPool = new(
+            () => new List<int>(),
+            onRelease: list => list.Clear()
+        );
+
         [Test]
         public void GenericPoolListTests()
         {
             {
-                using PooledResource<List<int>> firstList = WallstopGenericPool<List<int>>.Get();
-                using PooledResource<List<int>> secondList = WallstopGenericPool<List<int>>.Get();
+                using PooledResource<List<int>> firstList = _intPool.Get();
+                using PooledResource<List<int>> secondList = _intPool.Get();
                 Assert.AreNotEqual(firstList, secondList);
                 firstList.resource.Add(1);
                 Assert.AreEqual(1, firstList.resource.Count);
@@ -32,7 +37,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
             }
             {
                 // Ensure cleared
-                using PooledResource<List<int>> firstList = WallstopGenericPool<List<int>>.Get();
+                using PooledResource<List<int>> firstList = _intPool.Get();
                 Assert.AreEqual(0, firstList.resource.Count);
             }
         }
@@ -654,7 +659,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
         [Test]
         public void WallstopGenericPoolGetReturnsValidPooledResource()
         {
-            using PooledResource<List<int>> pooled = WallstopGenericPool<List<int>>.Get();
+            using PooledResource<List<int>> pooled = _intPool.Get();
 
             Assert.NotNull(pooled.resource);
             Assert.AreEqual(0, pooled.resource.Count);
@@ -665,14 +670,14 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
         {
             List<int> firstList;
 
-            using (PooledResource<List<int>> pooled = WallstopGenericPool<List<int>>.Get())
+            using (PooledResource<List<int>> pooled = _intPool.Get())
             {
                 firstList = pooled.resource;
                 firstList.Add(42);
                 firstList.Add(100);
             }
 
-            using PooledResource<List<int>> pooledReused = WallstopGenericPool<List<int>>.Get();
+            using PooledResource<List<int>> pooledReused = _intPool.Get();
             Assert.AreSame(firstList, pooledReused.resource);
             Assert.AreEqual(0, pooledReused.resource.Count);
         }
@@ -680,9 +685,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
         [Test]
         public void WallstopGenericPoolClearActionWorksWithCustomType()
         {
-            using PooledResource<HashSet<string>> pooled = WallstopGenericPool<
-                HashSet<string>
-            >.Get();
+            using WallstopGenericPool<HashSet<string>> pool = new(() => new HashSet<string>());
+            using PooledResource<HashSet<string>> pooled = pool.Get();
 
             pooled.resource.Add("test1");
             pooled.resource.Add("test2");
@@ -692,29 +696,30 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
         [Test]
         public void PooledResourceDisposeCallsOnDisposeAction()
         {
+            bool clearCalled = false;
             bool disposeCalled = false;
-            WallstopGenericPool<List<int>>.clearAction ??= list => list.Clear();
-            WallstopGenericPool<List<int>>.clearAction += Callback;
-            try
             {
-                using (PooledResource<List<int>> pooled = WallstopGenericPool<List<int>>.Get())
+                using WallstopGenericPool<List<int>> pool = new(
+                    () => new List<int>(),
+                    onRelease: list =>
+                    {
+                        list.Clear();
+                        clearCalled = true;
+                    },
+                    onDisposal: _ => disposeCalled = true
+                );
+
+                using (PooledResource<List<int>> pooled = pool.Get())
                 {
                     Assert.NotNull(pooled.resource);
+                    Assert.IsFalse(clearCalled);
                     Assert.IsFalse(disposeCalled);
                 }
 
-                Assert.IsTrue(disposeCalled);
-            }
-            finally
-            {
-                WallstopGenericPool<List<int>>.clearAction -= Callback;
+                Assert.IsTrue(clearCalled);
             }
 
-            return;
-            void Callback(List<int> list)
-            {
-                disposeCalled = true;
-            }
+            Assert.IsTrue(disposeCalled);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc80.6",
+  "version": "2.0.0-rc80.8",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -35,28 +35,4 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+}