com.wallstop-studios.unity-helpers 2.0.0-rc27 → 2.0.0-rc31

package/Runtime/Core/Serialization/JsonConverters/Vector2Converter.cs

@@ -1,74 +1,74 @@
-namespace UnityHelpers.Core.Serialization.JsonConverters
-{
-    using System;
-    using System.Text.Json;
-    using System.Text.Json.Serialization;
-    using UnityEngine;
-
-    public sealed class Vector2Converter : JsonConverter<Vector2>
-    {
-        public static readonly Vector2Converter Instance = new();
-
-        private Vector2Converter() { }
-
-        public override Vector2 Read(
-            ref Utf8JsonReader reader,
-            Type typeToConvert,
-            JsonSerializerOptions options
-        )
-        {
-            if (reader.TokenType != JsonTokenType.StartObject)
-            {
-                throw new JsonException($"Invalid token type {reader.TokenType}");
-            }
-
-            float x = 0,
-                y = 0;
-
-            while (reader.Read())
-            {
-                if (reader.TokenType == JsonTokenType.EndObject)
-                {
-                    return new Vector2(x, y);
-                }
-
-                if (reader.TokenType == JsonTokenType.PropertyName)
-                {
-                    string propertyName = reader.GetString();
-                    reader.Read();
-                    switch (propertyName)
-                    {
-                        case "x":
-                        {
-                            x = reader.GetSingle();
-                            break;
-                        }
-                        case "y":
-                        {
-                            y = reader.GetSingle();
-                            break;
-                        }
-                        default:
-                        {
-                            throw new JsonException($"Unknown property: {propertyName}");
-                        }
-                    }
-                }
-            }
-
-            throw new JsonException("Incomplete JSON for Vector2");
-        }
-
-        public override void Write(
-            Utf8JsonWriter writer,
-            Vector2 value,
-            JsonSerializerOptions options
-        )
-        {
-            writer.WriteStartObject();
-            writer.WriteNumber("x", value.x);
-            writer.WriteNumber("y", value.y);
-            writer.WriteEndObject();
-        }
-    }
-}
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class Vector2Converter : JsonConverter<Vector2>
+    {
+        public static readonly Vector2Converter Instance = new();
+
+        private Vector2Converter() { }
+
+        public override Vector2 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
+
+            float x = 0,
+                y = 0;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Vector2(x, y);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "x":
+                        {
+                            x = reader.GetSingle();
+                            break;
+                        }
+                        case "y":
+                        {
+                            y = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Vector2");
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Vector2 value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber("x", value.x);
+            writer.WriteNumber("y", value.y);
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/Vector3Converter.cs

@@ -1,81 +1,81 @@
-namespace UnityHelpers.Core.Serialization.JsonConverters
-{
-    using System;
-    using System.Text.Json;
-    using System.Text.Json.Serialization;
-    using UnityEngine;
-
-    public sealed class Vector3Converter : JsonConverter<Vector3>
-    {
-        public static readonly Vector3Converter Instance = new();
-
-        private Vector3Converter() { }
-
-        public override Vector3 Read(
-            ref Utf8JsonReader reader,
-            Type typeToConvert,
-            JsonSerializerOptions options
-        )
-        {
-            if (reader.TokenType != JsonTokenType.StartObject)
-            {
-                throw new JsonException($"Invalid token type {reader.TokenType}");
-            }
-
-            float x = 0,
-                y = 0,
-                z = 0;
-
-            while (reader.Read())
-            {
-                if (reader.TokenType == JsonTokenType.EndObject)
-                {
-                    return new Vector3(x, y, z);
-                }
-
-                if (reader.TokenType == JsonTokenType.PropertyName)
-                {
-                    string propertyName = reader.GetString();
-                    reader.Read();
-                    switch (propertyName)
-                    {
-                        case "x":
-                        {
-                            x = reader.GetSingle();
-                            break;
-                        }
-                        case "y":
-                        {
-                            y = reader.GetSingle();
-                            break;
-                        }
-                        case "z":
-                        {
-                            z = reader.GetSingle();
-                            break;
-                        }
-                        default:
-                        {
-                            throw new JsonException($"Unknown property: {propertyName}");
-                        }
-                    }
-                }
-            }
-
-            throw new JsonException("Incomplete JSON for Vector3");
-        }
-
-        public override void Write(
-            Utf8JsonWriter writer,
-            Vector3 value,
-            JsonSerializerOptions options
-        )
-        {
-            writer.WriteStartObject();
-            writer.WriteNumber("x", value.x);
-            writer.WriteNumber("y", value.y);
-            writer.WriteNumber("z", value.z);
-            writer.WriteEndObject();
-        }
-    }
-}
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class Vector3Converter : JsonConverter<Vector3>
+    {
+        public static readonly Vector3Converter Instance = new();
+
+        private Vector3Converter() { }
+
+        public override Vector3 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
+
+            float x = 0,
+                y = 0,
+                z = 0;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Vector3(x, y, z);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "x":
+                        {
+                            x = reader.GetSingle();
+                            break;
+                        }
+                        case "y":
+                        {
+                            y = reader.GetSingle();
+                            break;
+                        }
+                        case "z":
+                        {
+                            z = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Vector3");
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Vector3 value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber("x", value.x);
+            writer.WriteNumber("y", value.y);
+            writer.WriteNumber("z", value.z);
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/Serializer.cs

@@ -1,184 +1,184 @@
-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;
-
-    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,
-                },
-            };
-
-            PrettyJsonOptions = new JsonSerializerOptions
-            {
-                IgnoreReadOnlyFields = false,
-                IgnoreReadOnlyProperties = false,
-                ReferenceHandler = ReferenceHandler.IgnoreCycles,
-                PropertyNameCaseInsensitive = true,
-                IncludeFields = true,
-                Converters =
-                {
-                    new JsonStringEnumConverter(),
-                    Vector3Converter.Instance,
-                    Vector2Converter.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;
+
+    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,
+                },
+            };
+
+            PrettyJsonOptions = new JsonSerializerOptions
+            {
+                IgnoreReadOnlyFields = false,
+                IgnoreReadOnlyProperties = false,
+                ReferenceHandler = ReferenceHandler.IgnoreCycles,
+                PropertyNameCaseInsensitive = true,
+                IncludeFields = true,
+                Converters =
+                {
+                    new JsonStringEnumConverter(),
+                    Vector3Converter.Instance,
+                    Vector2Converter.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);
+        }
+    }
+}