BREAKING CHANGE: moved yaml serialization from Engine.Serialization to Engine.Integration

Engine.Integration/Engine.Integration.Yaml/Converters/SerializedClassConverter.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Engine.Core;
+using Engine.Core.Factory;
+using Engine.Core.Serialization;
+
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace Engine.Serializers.Yaml;
+
+public class SerializedClassConverter : EngineTypeYamlSerializerBase<SerializedClass>
+{
+    public override SerializedClass? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
+    {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .1f : ProgressionTracker.Progression, $"Reading class");
+
+        SerializedClass serializedClass = new();
+        Dictionary<string, TypeContainer> publicDictionary = [];
+        Dictionary<string, TypeContainer> privateDictionary = [];
+
+        parser.Consume<MappingStart>();
+
+        while (!parser.TryConsume<MappingEnd>(out _))
+        {
+            string key = parser.Consume<Scalar>().Value;
+
+            switch (key)
+            {
+                case nameof(SerializedClass.Type): serializedClass.Type = parser.Consume<Scalar>().Value; break;
+                case nameof(SerializedClass.Public): publicDictionary = (Dictionary<string, TypeContainer>)rootDeserializer(typeof(Dictionary<string, TypeContainer>))!; break;
+                case nameof(SerializedClass.Private): privateDictionary = (Dictionary<string, TypeContainer>)rootDeserializer(typeof(Dictionary<string, TypeContainer>))!; break;
+            }
+        }
+
+        foreach ((string key, TypeContainer typeContainer) in publicDictionary)
+            serializedClass.Public.Add(key, Serializer.InternalDeserialize(typeContainer.Value!.ToString()!, TypeFactory.GetType(typeContainer.Type)));
+
+        foreach ((string key, TypeContainer typeContainer) in privateDictionary)
+            serializedClass.Private.Add(key, Serializer.InternalDeserialize(typeContainer.Value!.ToString()!, TypeFactory.GetType(typeContainer.Type)));
+
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Read {serializedClass.Type}");
+        return serializedClass;
+    }
+
+    public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
+    {
+        SerializedClass serializedClass = (SerializedClass)value!;
+
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing {serializedClass.Type}");
+
+        Dictionary<string, TypeContainer> publics = [];
+        Dictionary<string, TypeContainer> privates = [];
+
+        foreach ((string key, object? @object) in serializedClass.Public.Where(v => !v.GetType().HasAttribute<IgnoreSerializationAttribute>()))
+            publics.Add(key, new TypeContainer(@object));
+
+        foreach ((string key, object? @object) in serializedClass.Private.Where(v => !v.GetType().HasAttribute<IgnoreSerializationAttribute>()))
+            privates.Add(key, new TypeContainer(@object));
+
+        emitter.Emit(new MappingStart());
+
+        emitter.Emit(new Scalar(nameof(SerializedClass.Type)));
+        emitter.Emit(new Scalar(serializedClass.Type));
+
+        if (publics.Count > 0)
+        {
+            emitter.Emit(new Scalar(nameof(SerializedClass.Public)));
+            serializer(publics);
+        }
+
+        if (privates.Count > 0)
+        {
+            emitter.Emit(new Scalar(nameof(SerializedClass.Private)));
+            serializer(privates);
+        }
+
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized {serializedClass.Type}");
+        emitter.Emit(new MappingEnd());
+    }
+}