com.wallstop-studios.unity-helpers 2.0.0-rc79.3 → 2.0.0-rc79.4

package/Runtime/Utils/Buffers.cs

@@ -1,6 +1,8 @@
 namespace WallstopStudios.UnityHelpers.Utils
 {
+    using System;
     using System.Collections.Generic;
+    using System.Reflection;
     using System.Text;
     using UnityEngine;
 
@@ -27,11 +29,125 @@ namespace WallstopStudios.UnityHelpers.Utils
 
     public static class Buffers<T>
     {
-        public static readonly T[] Array = new T[Buffers.BufferSize];
         public static readonly List<T> List = new();
         public static readonly HashSet<T> HashSet = new();
         public static readonly Queue<T> Queue = new();
         public static readonly Stack<T> Stack = new();
-        public static readonly LinkedList<T> LinkedList = new();
+    }
+
+    public static class GenericPool<T>
+        where T : new()
+    {
+        private static readonly List<T> _pool = new();
+        private static readonly Action<T> _clearAction = GetClearAction();
+        private static readonly Action<T> _onDispose = Release;
+
+        public static PooledResource<T> Get()
+        {
+            if (_pool.Count == 0)
+            {
+                return new PooledResource<T>(new T(), _onDispose);
+            }
+
+            int lastIndex = _pool.Count - 1;
+            T instance = _pool[lastIndex];
+            _pool.RemoveAt(lastIndex);
+            return new PooledResource<T>(instance, _onDispose);
+        }
+
+        private static Action<T> GetClearAction()
+        {
+            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);
+                }
+            }
+
+            return _ => { };
+        }
+
+        private static void Release(T resource)
+        {
+            _clearAction.Invoke(resource);
+            _pool.Add(resource);
+        }
+    }
+
+    public static class ArrayPool<T>
+    {
+        private static readonly Dictionary<int, List<T[]>> _pool = new();
+        private static readonly Action<T[]> _onDispose = 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>(), _ => { });
+                }
+            }
+
+            if (!_pool.TryGetValue(size, out List<T[]> pool))
+            {
+                pool = new List<T[]>();
+                _pool[size] = pool;
+            }
+
+            if (pool.Count == 0)
+            {
+                return new PooledResource<T[]>(new T[size], _onDispose);
+            }
+
+            int lastIndex = pool.Count - 1;
+            T[] instance = pool[lastIndex];
+            pool.RemoveAt(lastIndex);
+            return new PooledResource<T[]>(instance, _onDispose);
+        }
+
+        private static void Release(T[] resource)
+        {
+            int length = resource.Length;
+            Array.Clear(resource, 0, length);
+            if (!_pool.TryGetValue(length, out List<T[]> pool))
+            {
+                pool = new List<T[]>();
+                _pool[resource.Length] = pool;
+            }
+            pool.Add(resource);
+        }
+    }
+
+    public readonly struct PooledResource<T> : IDisposable
+    {
+        public readonly T resource;
+        private readonly Action<T> _onDispose;
+
+        internal PooledResource(T resource, Action<T> onDispose)
+        {
+            this.resource = resource;
+            _onDispose = onDispose ?? throw new ArgumentNullException(nameof(onDispose));
+        }
+
+        public void Dispose()
+        {
+            _onDispose(resource);
+        }
     }
 }

package/Tests/Runtime/Utils/BuffersTests.cs

@@ -0,0 +1,55 @@
+namespace WallstopStudios.UnityHelpers.Tests.Utils
+{
+    using System.Collections.Generic;
+    using NUnit.Framework;
+    using WallstopStudios.UnityHelpers.Core.Random;
+    using WallstopStudios.UnityHelpers.Utils;
+
+    public sealed class BuffersTests
+    {
+        [Test]
+        public void GenericPoolListTests()
+        {
+            {
+                using PooledResource<List<int>> firstList = GenericPool<List<int>>.Get();
+                using PooledResource<List<int>> secondList = GenericPool<List<int>>.Get();
+                Assert.AreNotEqual(firstList, secondList);
+                firstList.resource.Add(1);
+                Assert.AreEqual(1, firstList.resource.Count);
+                Assert.AreEqual(0, secondList.resource.Count);
+                secondList.resource.Add(2);
+                Assert.AreEqual(1, firstList.resource.Count);
+                Assert.AreEqual(1, secondList.resource.Count);
+            }
+            {
+                // Ensure cleared
+                using PooledResource<List<int>> firstList = GenericPool<List<int>>.Get();
+                Assert.AreEqual(0, firstList.resource.Count);
+            }
+        }
+
+        [Test]
+        public void ArrayPoolSizeTests()
+        {
+            for (int i = 0; i < 100; ++i)
+            {
+                using PooledResource<int[]> resource = ArrayPool<int>.Get(i);
+                Assert.AreEqual(i, resource.resource.Length);
+                for (int j = 0; j < i; ++j)
+                {
+                    resource.resource[j] = PRNG.Instance.Next();
+                }
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                using PooledResource<int[]> resource = ArrayPool<int>.Get(i);
+                Assert.AreEqual(i, resource.resource.Length);
+                for (int j = 0; j < i; ++j)
+                {
+                    Assert.AreEqual(0, resource.resource[j]);
+                }
+            }
+        }
+    }
+}

package/Tests/Runtime/Utils/BuffersTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ebd1e08428b148a88cdc89327b9ba8f0
+timeCreated: 1757790054

package/package.json

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