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

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

@@ -35,7 +35,7 @@ namespace WallstopStudios.UnityHelpers.Utils
         public static readonly Stack<T> Stack = new();
     }
 
-    public static class GenericPool<T>
+    public static class WallstopGenericPool<T>
         where T : new()
     {
         private static readonly List<T> _pool = new();
@@ -81,7 +81,7 @@ namespace WallstopStudios.UnityHelpers.Utils
         }
     }
 
-    public static class ArrayPool<T>
+    public static class WallstopArrayPool<T>
     {
         private static readonly Dictionary<int, List<T[]>> _pool = new();
         private static readonly Action<T[]> _onDispose = Release;

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;
         }

package/Runtime/Utils/SevenZip/Compress/LZ/LzBinTree.cs

@@ -62,7 +62,10 @@ namespace SevenZip.Compression.LZ
         {
             base.Init();
             for (UInt32 i = 0; i < _hashSizeSum; i++)
+            {
                 _hash[i] = kEmptyHashValue;
+            }
+
             _cyclicBufferPos = 0;
             ReduceOffsets(-1);
         }
@@ -70,10 +73,15 @@ namespace SevenZip.Compression.LZ
         public new void MovePos()
         {
             if (++_cyclicBufferPos >= _cyclicBufferSize)
+            {
                 _cyclicBufferPos = 0;
+            }
+
             base.MovePos();
             if (_pos == kMaxValForNormalize)
+            {
                 Normalize();
+            }
         }
 
         public new Byte GetIndexByte(Int32 index)
@@ -99,7 +107,10 @@ namespace SevenZip.Compression.LZ
         )
         {
             if (historySize > kMaxValForNormalize - 256)
+            {
                 throw new Exception();
+            }
+
             _cutValue = 16 + (matchMaxLen >> 1);
 
             UInt32 windowReservSize =
@@ -115,7 +126,9 @@ namespace SevenZip.Compression.LZ
 
             UInt32 cyclicBufferSize = historySize + 1;
             if (_cyclicBufferSize != cyclicBufferSize)
+            {
                 _son = new UInt32[(_cyclicBufferSize = cyclicBufferSize) * 2];
+            }
 
             UInt32 hs = kBT2HashSize;
 
@@ -129,20 +142,27 @@ namespace SevenZip.Compression.LZ
                 hs >>= 1;
                 hs |= 0xFFFF;
                 if (hs > (1 << 24))
+                {
                     hs >>= 1;
+                }
+
                 _hashMask = hs;
                 hs++;
                 hs += kFixHashSize;
             }
             if (hs != _hashSizeSum)
+            {
                 _hash = new UInt32[_hashSizeSum = hs];
+            }
         }
 
         public UInt32 GetMatches(UInt32[] distances)
         {
             UInt32 lenLimit;
             if (_pos + _matchMaxLen <= _streamPos)
+            {
                 lenLimit = _matchMaxLen;
+            }
             else
             {
                 lenLimit = _streamPos - _pos;
@@ -170,7 +190,9 @@ namespace SevenZip.Compression.LZ
                 hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
             }
             else
+            {
                 hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
+            }
 
             UInt32 curMatch = _hash[kFixHashSize + hashValue];
             if (HASH_ARRAY)
@@ -180,20 +202,29 @@ namespace SevenZip.Compression.LZ
                 _hash[hash2Value] = _pos;
                 _hash[kHash3Offset + hash3Value] = _pos;
                 if (curMatch2 > matchMinPos)
+                {
                     if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
                     {
                         distances[offset++] = maxLen = 2;
                         distances[offset++] = _pos - curMatch2 - 1;
                     }
+                }
+
                 if (curMatch3 > matchMinPos)
+                {
                     if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
                     {
                         if (curMatch3 == curMatch2)
+                        {
                             offset -= 2;
+                        }
+
                         distances[offset++] = maxLen = 3;
                         distances[offset++] = _pos - curMatch3 - 1;
                         curMatch2 = curMatch3;
                     }
+                }
+
                 if (offset != 0 && curMatch2 == curMatch)
                 {
                     offset -= 2;
@@ -247,8 +278,13 @@ namespace SevenZip.Compression.LZ
                 if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
                 {
                     while (++len != lenLimit)
+                    {
                         if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
+                        {
                             break;
+                        }
+                    }
+
                     if (maxLen < len)
                     {
                         distances[offset++] = maxLen = len;
@@ -286,7 +322,9 @@ namespace SevenZip.Compression.LZ
             {
                 UInt32 lenLimit;
                 if (_pos + _matchMaxLen <= _streamPos)
+                {
                     lenLimit = _matchMaxLen;
+                }
                 else
                 {
                     lenLimit = _streamPos - _pos;
@@ -313,7 +351,9 @@ namespace SevenZip.Compression.LZ
                     hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
                 }
                 else
+                {
                     hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
+                }
 
                 UInt32 curMatch = _hash[kFixHashSize + hashValue];
                 _hash[kFixHashSize + hashValue] = _pos;
@@ -347,8 +387,13 @@ namespace SevenZip.Compression.LZ
                     if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
                     {
                         while (++len != lenLimit)
+                        {
                             if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
+                            {
                                 break;
+                            }
+                        }
+
                         if (len == lenLimit)
                         {
                             _son[ptr1] = _son[cyclicPos];
@@ -381,9 +426,14 @@ namespace SevenZip.Compression.LZ
             {
                 UInt32 value = items[i];
                 if (value <= subValue)
+                {
                     value = kEmptyHashValue;
+                }
                 else
+                {
                     value -= subValue;
+                }
+
                 items[i] = value;
             }
         }