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

package/.github/dependabot.yml

@@ -3,4 +3,8 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "weekly"
+    assignees:
+      - wallstop
+    reviewers:
+      - wallstop

package/.github/workflows/npm-publish.yml

@@ -14,12 +14,12 @@ jobs:
 
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0  # Ensure full commit history for version comparison
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: 18
           registry-url: 'https://registry.npmjs.org/'

package/Runtime/Core/Extension/IReadonlyListExtensions.cs

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Core.Extension
+namespace WallstopStudios.UnityHelpers.Core.Extension
 {
     using System;
     using System.Collections.Generic;

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

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
+fileFormatVersion: 2
 guid: 8c6bf3a13af8429cb8e738bd09541780
 timeCreated: 1757613609

package/Runtime/Core/Extension/StringExtensions.cs

@@ -8,7 +8,7 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
 
     public static class StringExtensions
     {
-        private static ThreadLocal<StringBuilder> StringBuilderCache = new(() =>
+        private static readonly ThreadLocal<StringBuilder> StringBuilderCache = new(() =>
             new StringBuilder()
         );
 

package/Runtime/Core/Helper/StringInList.cs

@@ -6,21 +6,15 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
 
     public sealed class StringInList : PropertyAttribute
     {
-        public delegate string[] GetStringList();
-
-        private bool _shouldRefresh;
-        private string[] _list;
-        private Func<string[]> _getStringList;
+        private readonly Func<string[]> _getStringList;
 
         public StringInList(params string[] list)
         {
-            _shouldRefresh = false;
-            _list = list;
+            _getStringList = () => list;
         }
 
         public StringInList(Type type, string methodName)
         {
-            _shouldRefresh = true;
             MethodInfo method = type.GetMethod(
                 methodName,
                 BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic
@@ -36,18 +30,6 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
             }
         }
 
-        public string[] List
-        {
-            get
-            {
-                if (_shouldRefresh)
-                {
-                    return _getStringList();
-                }
-
-                return _list;
-            }
-            private set { _list = value; }
-        }
+        public string[] List => _getStringList();
     }
 }

package/Runtime/Core/Threading/SingleThreadedThreadPool.cs

@@ -3,116 +3,224 @@ namespace WallstopStudios.UnityHelpers.Core.Threading
     using System;
     using System.Collections.Concurrent;
     using System.Threading;
+    using System.Threading.Tasks;
 
     public sealed class SingleThreadedThreadPool : IDisposable
     {
         public ConcurrentQueue<Exception> Exceptions => _exceptions;
-        public int Count => _work.Count + Interlocked.CompareExchange(ref _working, 0, 0);
-
-        private int _active;
-        private int _working;
-        private Thread _worker;
-        private readonly ConcurrentQueue<Action> _work;
-        private AutoResetEvent _waitHandle;
-        private bool _disposed;
+        public int Count => _work.Count + (_isWorking ? 1 : 0);
+
+        private volatile bool _active = true;
+        private volatile bool _isWorking;
+        private volatile bool _disposed;
+
+        private readonly Task _workerTask;
+        private readonly ConcurrentQueue<WorkItem> _work;
+        private readonly SemaphoreSlim _workAvailable;
         private readonly ConcurrentQueue<Exception> _exceptions;
         private readonly TimeSpan _noWorkWaitTime;
+        private readonly CancellationTokenSource _cancellationTokenSource;
 
         public SingleThreadedThreadPool(
-            bool runInBackground = false,
+            bool runInBackground = true,
             TimeSpan? noWorkWaitTime = null
         )
         {
-            _active = 1;
-            _working = 1;
-            _work = new ConcurrentQueue<Action>();
+            _work = new ConcurrentQueue<WorkItem>();
             _exceptions = new ConcurrentQueue<Exception>();
-            _waitHandle = new AutoResetEvent(false);
+            _workAvailable = new SemaphoreSlim(0);
             _noWorkWaitTime = noWorkWaitTime ?? TimeSpan.FromSeconds(1);
-            _worker = new Thread(DoWork) { IsBackground = runInBackground };
-            _worker.Start();
-        }
+            _cancellationTokenSource = new CancellationTokenSource();
 
-        ~SingleThreadedThreadPool()
-        {
-            Dispose(false);
+            _workerTask = runInBackground
+                ? Task.Run(DoWorkAsync)
+                : Task.Factory.StartNew(DoWorkAsync, TaskCreationOptions.LongRunning).Unwrap();
         }
 
         public void Enqueue(Action work)
         {
-            _work.Enqueue(work);
-            _ = _waitHandle.Set();
+            if (_disposed || !_active)
+            {
+                return;
+            }
+
+            _work.Enqueue(WorkItem.FromAction(work));
+            Signal();
         }
 
-        public void Dispose()
+        public void Enqueue(Func<Task> work)
         {
-            Dispose(true);
-            GC.SuppressFinalize(this);
+            if (_disposed || !_active)
+            {
+                return;
+            }
+
+            _work.Enqueue(WorkItem.FromTask(work));
+            Signal();
         }
 
-        public void Dispose(bool disposing)
+        public void Enqueue(Func<ValueTask> work)
         {
-            if (_disposed)
+            if (_disposed || !_active)
             {
                 return;
             }
 
-            Interlocked.Exchange(ref _active, 0);
+            _work.Enqueue(WorkItem.FromValueTask(work));
+            Signal();
+        }
 
-            if (disposing)
+        private void Signal()
+        {
+            try
             {
-                try
-                {
-                    _worker?.Join(TimeSpan.FromSeconds(30));
-                    _waitHandle?.Dispose();
-                }
-                catch
-                {
-                    // Swallow
-                }
+                _workAvailable.Release();
+            }
+            catch
+            {
+                // Swallow
+            }
+        }
 
-                _waitHandle = null;
-                _worker = null;
+        public async ValueTask DisposeAsync()
+        {
+            if (_disposed)
+            {
+                return;
             }
 
+            _active = false;
             _disposed = true;
+
+            _cancellationTokenSource.Cancel();
+            Signal();
+            try
+            {
+                await _workerTask.ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                // Expected during shutdown
+            }
+            catch
+            {
+                // Swallow other exceptions during disposal
+            }
+
+            _cancellationTokenSource?.Dispose();
+            _workAvailable?.Dispose();
+
+            GC.SuppressFinalize(this);
+        }
+
+        public void Dispose()
+        {
+            DisposeAsync().AsTask().GetAwaiter().GetResult();
         }
 
-        private void DoWork()
+        private async Task DoWorkAsync()
         {
-            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
+            CancellationToken cancellationToken = _cancellationTokenSource.Token;
+
+            while (_active && !cancellationToken.IsCancellationRequested)
             {
                 try
                 {
-                    if (_work.TryDequeue(out Action workItem))
+                    if (_work.TryDequeue(out WorkItem workItem))
                     {
-                        _ = Interlocked.Exchange(ref _working, 1);
+                        _isWorking = true;
                         try
                         {
-                            workItem();
+                            await workItem.ExecuteAsync().ConfigureAwait(false);
                         }
                         catch (Exception e)
                         {
                             _exceptions.Enqueue(e);
                         }
+                        finally
+                        {
+                            _isWorking = false;
+                        }
                     }
                     else
                     {
                         try
                         {
-                            _ = _waitHandle?.WaitOne(_noWorkWaitTime);
+                            await _workAvailable
+                                .WaitAsync(_noWorkWaitTime, cancellationToken)
+                                .ConfigureAwait(false);
                         }
-                        catch (ObjectDisposedException)
+                        catch (OperationCanceledException)
                         {
-                            return;
+                            break;
                         }
                     }
                 }
-                finally
+                catch (ObjectDisposedException)
                 {
-                    _ = Interlocked.Exchange(ref _working, 0);
+                    break;
                 }
             }
         }
+
+        private enum WorkItemType
+        {
+            Unknown = 0,
+            Action = 1,
+            Task = 2,
+            ValueTask = 3,
+        }
+
+        private readonly struct WorkItem
+        {
+            private readonly WorkItemType _type;
+            private readonly Action _action;
+            private readonly Func<Task> _taskFunc;
+            private readonly Func<ValueTask> _valueTaskFunc;
+
+            private WorkItem(
+                WorkItemType type,
+                Action action = null,
+                Func<Task> taskFunc = null,
+                Func<ValueTask> valueTaskFunc = null
+            )
+            {
+                _type = type;
+                _action = action;
+                _taskFunc = taskFunc;
+                _valueTaskFunc = valueTaskFunc;
+            }
+
+            public static WorkItem FromAction(Action action) =>
+                new(WorkItemType.Action, action: action);
+
+            public static WorkItem FromTask(Func<Task> taskFunc) =>
+                new(WorkItemType.Task, taskFunc: taskFunc);
+
+            public static WorkItem FromValueTask(Func<ValueTask> valueTaskFunc) =>
+                new(WorkItemType.ValueTask, valueTaskFunc: valueTaskFunc);
+
+            public ValueTask ExecuteAsync()
+            {
+                return _type switch
+                {
+                    WorkItemType.Action => ExecuteAction(),
+                    WorkItemType.Task => ExecuteTask(),
+                    WorkItemType.ValueTask => _valueTaskFunc(),
+                    _ => default,
+                };
+            }
+
+            private ValueTask ExecuteAction()
+            {
+                _action();
+                return default;
+            }
+
+            private async ValueTask ExecuteTask()
+            {
+                await _taskFunc().ConfigureAwait(false);
+            }
+        }
     }
 }

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 WallstopGenericPool<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 WallstopArrayPool<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/Runtime/Utils/SevenZip/Common/CRC.cs

@@ -14,10 +14,17 @@ namespace SevenZip
             {
                 uint r = i;
                 for (int j = 0; j < 8; j++)
+                {
                     if ((r & 1) != 0)
+                    {
                         r = (r >> 1) ^ kPoly;
+                    }
                     else
+                    {
                         r >>= 1;
+                    }
+                }
+
                 Table[i] = r;
             }
         }
@@ -37,7 +44,9 @@ namespace SevenZip
         public void Update(byte[] data, uint offset, uint size)
         {
             for (uint i = 0; i < size; i++)
+            {
                 _value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);
+            }
         }
 
         public uint GetDigest()

package/Runtime/Utils/SevenZip/Common/InBuffer.cs

@@ -4,10 +4,10 @@ namespace SevenZip.Buffer
 {
     public class InBuffer
     {
-        byte[] m_Buffer;
+        readonly byte[] m_Buffer;
         uint m_Pos;
         uint m_Limit;
-        uint m_BufferSize;
+        readonly uint m_BufferSize;
         System.IO.Stream m_Stream;
         bool m_StreamWasExhausted;
         ulong m_ProcessedSize;
@@ -30,7 +30,10 @@ namespace SevenZip.Buffer
         public bool ReadBlock()
         {
             if (m_StreamWasExhausted)
+            {
                 return false;
+            }
+
             m_ProcessedSize += m_Pos;
             int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
             m_Pos = 0;
@@ -48,8 +51,13 @@ namespace SevenZip.Buffer
         public bool ReadByte(byte b) // check it
         {
             if (m_Pos >= m_Limit)
+            {
                 if (!ReadBlock())
+                {
                     return false;
+                }
+            }
+
             b = m_Buffer[m_Pos++];
             return true;
         }
@@ -58,8 +66,13 @@ namespace SevenZip.Buffer
         {
             // return (byte)m_Stream.ReadByte();
             if (m_Pos >= m_Limit)
+            {
                 if (!ReadBlock())
+                {
                     return 0xFF;
+                }
+            }
+
             return m_Buffer[m_Pos++];
         }
 

package/Runtime/Utils/SevenZip/Common/OutBuffer.cs

@@ -4,9 +4,9 @@ namespace SevenZip.Buffer
 {
     public class OutBuffer
     {
-        byte[] m_Buffer;
+        readonly byte[] m_Buffer;
         uint m_Pos;
-        uint m_BufferSize;
+        readonly uint m_BufferSize;
         System.IO.Stream m_Stream;
         ulong m_ProcessedSize;
 
@@ -46,13 +46,18 @@ namespace SevenZip.Buffer
         {
             m_Buffer[m_Pos++] = b;
             if (m_Pos >= m_BufferSize)
+            {
                 FlushData();
+            }
         }
 
         public void FlushData()
         {
             if (m_Pos == 0)
+            {
                 return;
+            }
+
             m_Stream.Write(m_Buffer, 0, (int)m_Pos);
             m_Pos = 0;
         }