com.wallstop-studios.unity-helpers 2.0.0-rc56 → 2.0.0-rc58

package/Runtime/Core/Serialization/Serializer.cs

@@ -1,195 +1,195 @@
-namespace UnityHelpers.Core.Serialization
-{
-    using System;
-    using System.ComponentModel;
-    using System.IO;
-    using System.Runtime.Serialization.Formatters.Binary;
-    using System.Text;
-    using System.Text.Json;
-    using System.Text.Json.Serialization;
-    using Extension;
-    using JsonConverters;
-    using TypeConverter = JsonConverters.TypeConverter;
-
-    internal static class SerializerEncoding
-    {
-        public static readonly Encoding Encoding;
-        public static readonly JsonSerializerOptions NormalJsonOptions;
-        public static readonly JsonSerializerOptions PrettyJsonOptions;
-
-        static SerializerEncoding()
-        {
-            Encoding = Encoding.UTF8;
-            NormalJsonOptions = new JsonSerializerOptions
-            {
-                IgnoreReadOnlyFields = false,
-                IgnoreReadOnlyProperties = false,
-                ReferenceHandler = ReferenceHandler.IgnoreCycles,
-                IncludeFields = true,
-                PropertyNameCaseInsensitive = true,
-                Converters =
-                {
-                    new JsonStringEnumConverter(),
-                    Vector3Converter.Instance,
-                    Vector2Converter.Instance,
-                    Vector4Converter.Instance,
-                    Matrix4x4Converter.Instance,
-                    TypeConverter.Instance,
-                    GameObjectConverter.Instance,
-                    ColorConverter.Instance,
-                },
-            };
-
-            PrettyJsonOptions = new JsonSerializerOptions
-            {
-                IgnoreReadOnlyFields = false,
-                IgnoreReadOnlyProperties = false,
-                ReferenceHandler = ReferenceHandler.IgnoreCycles,
-                PropertyNameCaseInsensitive = true,
-                IncludeFields = true,
-                Converters =
-                {
-                    new JsonStringEnumConverter(),
-                    Vector3Converter.Instance,
-                    Vector2Converter.Instance,
-                    Vector4Converter.Instance,
-                    Matrix4x4Converter.Instance,
-                    TypeConverter.Instance,
-                    GameObjectConverter.Instance,
-                    ColorConverter.Instance,
-                },
-                WriteIndented = true,
-            };
-        }
-    }
-
-    public enum SerializationType
-    {
-        SystemBinary,
-        Protobuf,
-    }
-
-    public static class Serializer
-    {
-        public static T Deserialize<T>(byte[] serialized, SerializationType serializationType)
-        {
-            switch (serializationType)
-            {
-                case SerializationType.SystemBinary:
-                    return BinaryDeserialize<T>(serialized);
-                case SerializationType.Protobuf:
-                    return ProtoDeserialize<T>(serialized);
-                default:
-                    throw new InvalidEnumArgumentException(
-                        nameof(serializationType),
-                        (int)serializationType,
-                        typeof(SerializationType)
-                    );
-            }
-        }
-
-        public static byte[] Serialize<T>(T instance, SerializationType serializationType)
-        {
-            switch (serializationType)
-            {
-                case SerializationType.SystemBinary:
-                    return BinarySerialize(instance);
-                case SerializationType.Protobuf:
-                    return ProtoSerialize(instance);
-                default:
-                    throw new InvalidEnumArgumentException(
-                        nameof(serializationType),
-                        (int)serializationType,
-                        typeof(SerializationType)
-                    );
-            }
-        }
-
-        public static T BinaryDeserialize<T>(byte[] data)
-        {
-            using MemoryStream memoryStream = new(data);
-            BinaryFormatter binaryFormatter = new();
-            memoryStream.Position = 0;
-            return (T)binaryFormatter.Deserialize(memoryStream);
-        }
-
-        public static byte[] BinarySerialize<T>(T input)
-        {
-            using MemoryStream memoryStream = new();
-            BinaryFormatter binaryFormatter = new();
-            binaryFormatter.Serialize(memoryStream, input);
-            return memoryStream.ToArray();
-        }
-
-        public static T ProtoDeserialize<T>(byte[] data)
-        {
-            using MemoryStream memoryStream = new(data);
-            return ProtoBuf.Serializer.Deserialize<T>(memoryStream);
-        }
-
-        public static T ProtoDeserialize<T>(byte[] data, Type type)
-        {
-            using MemoryStream memoryStream = new(data);
-            return (T)ProtoBuf.Serializer.Deserialize(type, memoryStream);
-        }
-
-        public static byte[] ProtoSerialize<T>(T input)
-        {
-            using MemoryStream memoryStream = new();
-            ProtoBuf.Serializer.Serialize(memoryStream, input);
-            return memoryStream.ToArray();
-        }
-
-        public static T JsonDeserialize<T>(string data, Type type = null)
-        {
-            return (T)
-                JsonSerializer.Deserialize(
-                    data,
-                    type ?? typeof(T),
-                    SerializerEncoding.NormalJsonOptions
-                );
-        }
-
-        public static byte[] JsonSerialize<T>(T input)
-        {
-            return JsonStringify(input).GetBytes();
-        }
-
-        public static string JsonStringify<T>(T input, bool pretty = false)
-        {
-            JsonSerializerOptions options = pretty
-                ? SerializerEncoding.PrettyJsonOptions
-                : SerializerEncoding.NormalJsonOptions;
-            Type parameterType = typeof(T);
-            if (
-                parameterType.IsAbstract
-                || parameterType.IsInterface
-                || parameterType == typeof(object)
-            )
-            {
-                object data = input;
-                if (data == null)
-                {
-                    return "{}";
-                }
-
-                Type type = data.GetType();
-                return JsonSerializer.Serialize(data, type, options);
-            }
-
-            return JsonSerializer.Serialize(input, options);
-        }
-
-        public static T ReadFromJsonFile<T>(string path)
-        {
-            string settingsAsText = File.ReadAllText(path, SerializerEncoding.Encoding);
-            return JsonDeserialize<T>(settingsAsText);
-        }
-
-        public static void WriteToJsonFile<T>(T input, string path, bool pretty = true)
-        {
-            string jsonAsText = JsonStringify(input, pretty);
-            File.WriteAllText(path, jsonAsText);
-        }
-    }
-}
+namespace UnityHelpers.Core.Serialization
+{
+    using System;
+    using System.ComponentModel;
+    using System.IO;
+    using System.Runtime.Serialization.Formatters.Binary;
+    using System.Text;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using Extension;
+    using JsonConverters;
+    using TypeConverter = JsonConverters.TypeConverter;
+
+    internal static class SerializerEncoding
+    {
+        public static readonly Encoding Encoding;
+        public static readonly JsonSerializerOptions NormalJsonOptions;
+        public static readonly JsonSerializerOptions PrettyJsonOptions;
+
+        static SerializerEncoding()
+        {
+            Encoding = Encoding.UTF8;
+            NormalJsonOptions = new JsonSerializerOptions
+            {
+                IgnoreReadOnlyFields = false,
+                IgnoreReadOnlyProperties = false,
+                ReferenceHandler = ReferenceHandler.IgnoreCycles,
+                IncludeFields = true,
+                PropertyNameCaseInsensitive = true,
+                Converters =
+                {
+                    new JsonStringEnumConverter(),
+                    Vector3Converter.Instance,
+                    Vector2Converter.Instance,
+                    Vector4Converter.Instance,
+                    Matrix4x4Converter.Instance,
+                    TypeConverter.Instance,
+                    GameObjectConverter.Instance,
+                    ColorConverter.Instance,
+                },
+            };
+
+            PrettyJsonOptions = new JsonSerializerOptions
+            {
+                IgnoreReadOnlyFields = false,
+                IgnoreReadOnlyProperties = false,
+                ReferenceHandler = ReferenceHandler.IgnoreCycles,
+                PropertyNameCaseInsensitive = true,
+                IncludeFields = true,
+                Converters =
+                {
+                    new JsonStringEnumConverter(),
+                    Vector3Converter.Instance,
+                    Vector2Converter.Instance,
+                    Vector4Converter.Instance,
+                    Matrix4x4Converter.Instance,
+                    TypeConverter.Instance,
+                    GameObjectConverter.Instance,
+                    ColorConverter.Instance,
+                },
+                WriteIndented = true,
+            };
+        }
+    }
+
+    public enum SerializationType
+    {
+        SystemBinary,
+        Protobuf,
+    }
+
+    public static class Serializer
+    {
+        public static T Deserialize<T>(byte[] serialized, SerializationType serializationType)
+        {
+            switch (serializationType)
+            {
+                case SerializationType.SystemBinary:
+                    return BinaryDeserialize<T>(serialized);
+                case SerializationType.Protobuf:
+                    return ProtoDeserialize<T>(serialized);
+                default:
+                    throw new InvalidEnumArgumentException(
+                        nameof(serializationType),
+                        (int)serializationType,
+                        typeof(SerializationType)
+                    );
+            }
+        }
+
+        public static byte[] Serialize<T>(T instance, SerializationType serializationType)
+        {
+            switch (serializationType)
+            {
+                case SerializationType.SystemBinary:
+                    return BinarySerialize(instance);
+                case SerializationType.Protobuf:
+                    return ProtoSerialize(instance);
+                default:
+                    throw new InvalidEnumArgumentException(
+                        nameof(serializationType),
+                        (int)serializationType,
+                        typeof(SerializationType)
+                    );
+            }
+        }
+
+        public static T BinaryDeserialize<T>(byte[] data)
+        {
+            using MemoryStream memoryStream = new(data);
+            BinaryFormatter binaryFormatter = new();
+            memoryStream.Position = 0;
+            return (T)binaryFormatter.Deserialize(memoryStream);
+        }
+
+        public static byte[] BinarySerialize<T>(T input)
+        {
+            using MemoryStream memoryStream = new();
+            BinaryFormatter binaryFormatter = new();
+            binaryFormatter.Serialize(memoryStream, input);
+            return memoryStream.ToArray();
+        }
+
+        public static T ProtoDeserialize<T>(byte[] data)
+        {
+            using MemoryStream memoryStream = new(data);
+            return ProtoBuf.Serializer.Deserialize<T>(memoryStream);
+        }
+
+        public static T ProtoDeserialize<T>(byte[] data, Type type)
+        {
+            using MemoryStream memoryStream = new(data);
+            return (T)ProtoBuf.Serializer.Deserialize(type, memoryStream);
+        }
+
+        public static byte[] ProtoSerialize<T>(T input)
+        {
+            using MemoryStream memoryStream = new();
+            ProtoBuf.Serializer.Serialize(memoryStream, input);
+            return memoryStream.ToArray();
+        }
+
+        public static T JsonDeserialize<T>(string data, Type type = null)
+        {
+            return (T)
+                JsonSerializer.Deserialize(
+                    data,
+                    type ?? typeof(T),
+                    SerializerEncoding.NormalJsonOptions
+                );
+        }
+
+        public static byte[] JsonSerialize<T>(T input)
+        {
+            return JsonStringify(input).GetBytes();
+        }
+
+        public static string JsonStringify<T>(T input, bool pretty = false)
+        {
+            JsonSerializerOptions options = pretty
+                ? SerializerEncoding.PrettyJsonOptions
+                : SerializerEncoding.NormalJsonOptions;
+            Type parameterType = typeof(T);
+            if (
+                parameterType.IsAbstract
+                || parameterType.IsInterface
+                || parameterType == typeof(object)
+            )
+            {
+                object data = input;
+                if (data == null)
+                {
+                    return "{}";
+                }
+
+                Type type = data.GetType();
+                return JsonSerializer.Serialize(data, type, options);
+            }
+
+            return JsonSerializer.Serialize(input, options);
+        }
+
+        public static T ReadFromJsonFile<T>(string path)
+        {
+            string settingsAsText = File.ReadAllText(path, SerializerEncoding.Encoding);
+            return JsonDeserialize<T>(settingsAsText);
+        }
+
+        public static void WriteToJsonFile<T>(T input, string path, bool pretty = true)
+        {
+            string jsonAsText = JsonStringify(input, pretty);
+            File.WriteAllText(path, jsonAsText);
+        }
+    }
+}

package/Runtime/Core/Threading/SingleThreadedThreadPool.cs

@@ -1,113 +1,113 @@
-namespace UnityHelpers.Core.Threading
-{
-    using System;
-    using System.Collections.Concurrent;
-    using System.Threading;
-
-    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;
-        private readonly ConcurrentQueue<Exception> _exceptions;
-
-        public SingleThreadedThreadPool(bool runInBackground = false)
-        {
-            _active = 1;
-            _working = 1;
-            _work = new ConcurrentQueue<Action>();
-            _exceptions = new ConcurrentQueue<Exception>();
-            _waitHandle = new AutoResetEvent(false);
-            _worker = new Thread(DoWork) { IsBackground = runInBackground };
-            _worker.Start();
-        }
-
-        ~SingleThreadedThreadPool()
-        {
-            Dispose(false);
-        }
-
-        public void Enqueue(Action work)
-        {
-            _work.Enqueue(work);
-            _ = _waitHandle.Set();
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        public void Dispose(bool disposing)
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            Interlocked.Exchange(ref _active, 0);
-
-            if (disposing)
-            {
-                try
-                {
-                    _worker?.Join(TimeSpan.FromSeconds(30));
-                    _waitHandle?.Dispose();
-                }
-                catch
-                {
-                    // Swallow
-                }
-
-                _waitHandle = null;
-                _worker = null;
-            }
-
-            _disposed = true;
-        }
-
-        private void DoWork()
-        {
-            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
-            {
-                try
-                {
-                    if (_work.TryDequeue(out Action workItem))
-                    {
-                        _ = Interlocked.Exchange(ref _working, 1);
-                        try
-                        {
-                            workItem();
-                        }
-                        catch (Exception e)
-                        {
-                            _exceptions.Enqueue(e);
-                        }
-                    }
-                    else
-                    {
-                        try
-                        {
-                            _ = _waitHandle?.WaitOne(TimeSpan.FromSeconds(1));
-                        }
-                        catch (ObjectDisposedException)
-                        {
-                            return;
-                        }
-                    }
-                }
-                finally
-                {
-                    _ = Interlocked.Exchange(ref _working, 0);
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Threading
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Threading;
+
+    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;
+        private readonly ConcurrentQueue<Exception> _exceptions;
+
+        public SingleThreadedThreadPool(bool runInBackground = false)
+        {
+            _active = 1;
+            _working = 1;
+            _work = new ConcurrentQueue<Action>();
+            _exceptions = new ConcurrentQueue<Exception>();
+            _waitHandle = new AutoResetEvent(false);
+            _worker = new Thread(DoWork) { IsBackground = runInBackground };
+            _worker.Start();
+        }
+
+        ~SingleThreadedThreadPool()
+        {
+            Dispose(false);
+        }
+
+        public void Enqueue(Action work)
+        {
+            _work.Enqueue(work);
+            _ = _waitHandle.Set();
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        public void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            Interlocked.Exchange(ref _active, 0);
+
+            if (disposing)
+            {
+                try
+                {
+                    _worker?.Join(TimeSpan.FromSeconds(30));
+                    _waitHandle?.Dispose();
+                }
+                catch
+                {
+                    // Swallow
+                }
+
+                _waitHandle = null;
+                _worker = null;
+            }
+
+            _disposed = true;
+        }
+
+        private void DoWork()
+        {
+            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
+            {
+                try
+                {
+                    if (_work.TryDequeue(out Action workItem))
+                    {
+                        _ = Interlocked.Exchange(ref _working, 1);
+                        try
+                        {
+                            workItem();
+                        }
+                        catch (Exception e)
+                        {
+                            _exceptions.Enqueue(e);
+                        }
+                    }
+                    else
+                    {
+                        try
+                        {
+                            _ = _waitHandle?.WaitOne(TimeSpan.FromSeconds(1));
+                        }
+                        catch (ObjectDisposedException)
+                        {
+                            return;
+                        }
+                    }
+                }
+                finally
+                {
+                    _ = Interlocked.Exchange(ref _working, 0);
+                }
+            }
+        }
+    }
+}