feat: async serializer methods

Engine.Core/Serialization/ISerializer.cs

@@ -9,4 +9,10 @@ public interface ISerializer
     T Deserialize<T>(string configuration);
 
     string Serialize(object instance);
+
+    ProgressiveTask<object> DeserializeAsync(string configuration);
+    ProgressiveTask<object> DeserializeAsync(string configuration, Type type);
+    ProgressiveTask<T> DeserializeAsync<T>(string configuration);
+
+    ProgressiveTask<string> SerializeAsync(object instance);
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/Abstract/IEngineTypeYamlConverter.cs

@@ -1,3 +1,4 @@
+using Syntriax.Engine.Core;
 using Syntriax.Engine.Core.Serialization;
 
 using YamlDotNet.Serialization;
@@ -8,4 +9,5 @@ public interface IEngineTypeYamlConverter : IYamlTypeConverter
 {
     YamlSerializer Serializer { get; set; }
     EntityRegistry EntityRegistry { get; set; }
+    IProgressionTracker ProgressionTracker { get; set; }
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/BehaviourControllerConverter.cs

@@ -17,6 +17,9 @@ public class BehaviourControllerConverter : EngineTypeYamlSerializerBase<IBehavi
 
     public override IBehaviourController? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
     {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Reading behaviour controller");
+
         string id;
 
         IBehaviourController behaviourController;
@@ -32,6 +35,7 @@ public class BehaviourControllerConverter : EngineTypeYamlSerializerBase<IBehavi
         if (parser.Consume<Scalar>().Value.CompareTo(SERIALIZED_SCALAR_NAME) != 0)
             throw new();
         SerializedClass instanceSerializedClass = (SerializedClass)rootDeserializer(typeof(SerializedClass))!;
+        ProgressionTracker.Set(isTrackingController ? .5f : ProgressionTracker.Progression, $"Creating {instanceSerializedClass.Type}");
         behaviourController = (IBehaviourController)instanceSerializedClass.CreateInstance(EntityRegistry);
 
         string value = parser.Consume<Scalar>().Value;
@@ -53,6 +57,7 @@ public class BehaviourControllerConverter : EngineTypeYamlSerializerBase<IBehavi
         foreach (IBehaviour behaviour in behaviours)
             behaviourController.AddBehaviour(behaviour);
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Created {instanceSerializedClass.Type}");
         return behaviourController;
     }
 
@@ -60,6 +65,9 @@ public class BehaviourControllerConverter : EngineTypeYamlSerializerBase<IBehavi
     {
         IBehaviourController behaviourController = (IBehaviourController)value!;
 
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing behaviour controller");
+
         emitter.Emit(new MappingStart());
 
         emitter.Emit(new Scalar(nameof(IBehaviourController.Id)));
@@ -74,6 +82,7 @@ public class BehaviourControllerConverter : EngineTypeYamlSerializerBase<IBehavi
         emitter.Emit(new Scalar(BEHAVIOURS_SCALAR_NAME));
         serializer(behaviourController.GetBehaviours<IBehaviour>().Where(b => !b.GetType().HasAttribute<IgnoreSerializationAttribute>()));
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized behaviour controller");
         emitter.Emit(new MappingEnd());
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/BehaviourConverter.cs

@@ -13,6 +13,9 @@ public class BehaviourConverter : EngineTypeYamlSerializerBase<IBehaviour>
 {
     public override IBehaviour? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
     {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Reading behaviour information");
+
         string id;
         int priority;
 
@@ -32,6 +35,7 @@ public class BehaviourConverter : EngineTypeYamlSerializerBase<IBehaviour>
         if (parser.Consume<Scalar>().Value.CompareTo(SERIALIZED_SCALAR_NAME) != 0)
             throw new();
         SerializedClass instanceSerializedClass = (SerializedClass)rootDeserializer(typeof(SerializedClass))!;
+        ProgressionTracker.Set(isTrackingController ? .5f : ProgressionTracker.Progression, $"Creating {instanceSerializedClass.Type}");
         behaviour = (IBehaviour)instanceSerializedClass.CreateInstance(EntityRegistry);
 
         if (parser.Consume<Scalar>().Value.CompareTo(nameof(IBehaviour.StateEnable)) != 0)
@@ -46,6 +50,7 @@ public class BehaviourConverter : EngineTypeYamlSerializerBase<IBehaviour>
         stateEnable.Assign(behaviour);
         behaviour.Assign(stateEnable);
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Created {instanceSerializedClass.Type}");
         return behaviour;
     }
 
@@ -53,6 +58,9 @@ public class BehaviourConverter : EngineTypeYamlSerializerBase<IBehaviour>
     {
         IBehaviour behaviour = (IBehaviour)value!;
 
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing behaviour");
+
         emitter.Emit(new MappingStart());
 
         emitter.Emit(new Scalar(nameof(IBehaviour.Id)));
@@ -67,6 +75,7 @@ public class BehaviourConverter : EngineTypeYamlSerializerBase<IBehaviour>
         emitter.Emit(new Scalar(nameof(IBehaviour.StateEnable)));
         serializer(behaviour.StateEnable);
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized behaviour");
         emitter.Emit(new MappingEnd());
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/EngineTypeYamlConverterBase.cs

@@ -14,6 +14,7 @@ public abstract class EngineTypeYamlSerializerBase<T> : IEngineTypeYamlConverter
 
     public EntityRegistry EntityRegistry { get; set; } = null!;
     public YamlSerializer Serializer { get; set; } = null!;
+    public IProgressionTracker ProgressionTracker { get; set; } = null!;
 
     public bool Accepts(Type type) => typeof(T).IsAssignableFrom(type);
 

Engine.Serializers/Engine.Serializers.Yaml/Converters/SerializedClassConverter.cs

@@ -2,8 +2,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-using Syntriax.Engine.Core.Serialization;
+using Syntriax.Engine.Core;
 using Syntriax.Engine.Core.Factory;
+using Syntriax.Engine.Core.Serialization;
 
 using YamlDotNet.Core;
 using YamlDotNet.Core.Events;
@@ -15,6 +16,9 @@ public class SerializedClassConverter : EngineTypeYamlSerializerBase<SerializedC
 {
     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 = [];
@@ -39,6 +43,7 @@ public class SerializedClassConverter : EngineTypeYamlSerializerBase<SerializedC
         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;
     }
 
@@ -46,6 +51,9 @@ public class SerializedClassConverter : EngineTypeYamlSerializerBase<SerializedC
     {
         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 = [];
 
@@ -72,6 +80,7 @@ public class SerializedClassConverter : EngineTypeYamlSerializerBase<SerializedC
             serializer(privates);
         }
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized {serializedClass.Type}");
         emitter.Emit(new MappingEnd());
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/StateEnableConverter.cs

@@ -13,6 +13,9 @@ public class StateEnableConverter : EngineTypeYamlSerializerBase<IStateEnable>
 {
     public override IStateEnable? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
     {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Reading state enable");
+
         bool enabled;
 
         IStateEnable stateEnable;
@@ -32,6 +35,7 @@ public class StateEnableConverter : EngineTypeYamlSerializerBase<IStateEnable>
 
         stateEnable.Enabled = enabled;
 
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Read state enable");
         return stateEnable;
     }
 
@@ -39,6 +43,9 @@ public class StateEnableConverter : EngineTypeYamlSerializerBase<IStateEnable>
     {
         IStateEnable stateEnable = (IStateEnable)value!;
 
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing state enable");
+
         emitter.Emit(new MappingStart());
 
         emitter.Emit(new Scalar(nameof(IStateEnable.Enabled)));
@@ -47,6 +54,7 @@ public class StateEnableConverter : EngineTypeYamlSerializerBase<IStateEnable>
         emitter.Emit(new Scalar(SERIALIZED_SCALAR_NAME));
         serializer(new SerializedClass(stateEnable));
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized state enable");
         emitter.Emit(new MappingEnd());
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/UniverseConverter.cs

@@ -15,6 +15,9 @@ public class UniverseConverter : EngineTypeYamlSerializerBase<IUniverse>
 {
     public override IUniverse? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
     {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? 0.1f : ProgressionTracker.Progression, "Reading universe");
+
         string id;
 
         IUniverse universe;
@@ -30,12 +33,14 @@ public class UniverseConverter : EngineTypeYamlSerializerBase<IUniverse>
         if (parser.Consume<Scalar>().Value.CompareTo(SERIALIZED_SCALAR_NAME) != 0)
             throw new();
         SerializedClass instanceSerializedClass = (SerializedClass)rootDeserializer(typeof(SerializedClass))!;
+        ProgressionTracker.Set(isTrackingController ? .2f : ProgressionTracker.Progression, $"Creating {instanceSerializedClass.Type}");
         universe = (IUniverse)instanceSerializedClass.CreateInstance(EntityRegistry);
 
         if (parser.Consume<Scalar>().Value.CompareTo(nameof(IUniverse.StateEnable)) != 0)
             throw new();
         stateEnable = (IStateEnable)rootDeserializer(typeof(IStateEnable))!;
 
+        ProgressionTracker.Set(isTrackingController ? .5f : ProgressionTracker.Progression, $"Reading universe objects");
         if (parser.Consume<Scalar>().Value.CompareTo(nameof(IUniverse.UniverseObjects)) != 0)
             throw new();
         universeObjects = (List<IUniverseObject>)rootDeserializer(typeof(List<IUniverseObject>))!;
@@ -47,9 +52,16 @@ public class UniverseConverter : EngineTypeYamlSerializerBase<IUniverse>
         stateEnable.Assign(universe);
         universe.Assign(stateEnable);
 
-        foreach (IUniverseObject uo in universeObjects)
+        ProgressionTracker.Set(isTrackingController ? .9f : ProgressionTracker.Progression, "Registering universe objects");
-            universe.Register(uo);
+        for (int i = 0; i < universeObjects.Count; i++)
+        {
+            IUniverseObject uo = universeObjects[i];
+            ProgressionTracker.Set(isTrackingController ? .9f + .1f * ((float)i / universeObjects.Count) : ProgressionTracker.Progression, $"Registering {uo.Name}");
 
+            universe.Register(uo);
+        }
+
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Created {instanceSerializedClass.Type}");
         return universe;
     }
 
@@ -57,16 +69,10 @@ public class UniverseConverter : EngineTypeYamlSerializerBase<IUniverse>
     {
         IUniverse universe = (IUniverse)value!;
 
-        IEnumerable<IUniverseObject> rootUniverseObjects = universe.UniverseObjects
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
-            .Select(uo =>
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing universe");
-            {
+
-                IUniverseObject root = uo;
+        IEnumerable<IUniverseObject> rootUniverseObjects = universe.UniverseObjects.Where(uo => uo.Parent is null);
-                while (root.Parent is IUniverseObject parent)
-                    root = parent;
-                return root;
-            })
-            .Where(uo => !uo.GetType().HasAttribute<IgnoreSerializationAttribute>())
-            .Distinct();
 
         emitter.Emit(new MappingStart());
 
@@ -82,6 +88,7 @@ public class UniverseConverter : EngineTypeYamlSerializerBase<IUniverse>
         emitter.Emit(new Scalar(nameof(IUniverse.UniverseObjects)));
         serializer(rootUniverseObjects);
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized universe");
         emitter.Emit(new MappingEnd());
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/Converters/UniverseObjectConverter.cs

@@ -15,6 +15,8 @@ public class UniverseObjectSerializer : EngineTypeYamlSerializerBase<IUniverseOb
 {
     public override IUniverseObject? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
     {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+
         string name;
         string id;
 
@@ -28,6 +30,7 @@ public class UniverseObjectSerializer : EngineTypeYamlSerializerBase<IUniverseOb
         if (parser.Consume<Scalar>().Value.CompareTo(nameof(IUniverseObject.Name)) != 0)
             throw new();
         name = parser.Consume<Scalar>().Value;
+        ProgressionTracker.Set(isTrackingController ? .1f : ProgressionTracker.Progression, $"Reading {name}");
 
         if (parser.Consume<Scalar>().Value.CompareTo(nameof(IUniverseObject.Id)) != 0)
             throw new();
@@ -36,6 +39,7 @@ public class UniverseObjectSerializer : EngineTypeYamlSerializerBase<IUniverseOb
         if (parser.Consume<Scalar>().Value.CompareTo(SERIALIZED_SCALAR_NAME) != 0)
             throw new();
         SerializedClass instanceSerializedClass = (SerializedClass)rootDeserializer(typeof(SerializedClass))!;
+        ProgressionTracker.Set(isTrackingController ? .3f : ProgressionTracker.Progression, $"Creating {instanceSerializedClass.Type}");
         universeObject = (IUniverseObject)instanceSerializedClass.CreateInstance(EntityRegistry);
 
         if (parser.Consume<Scalar>().Value.CompareTo(nameof(IUniverseObject.StateEnable)) != 0)
@@ -64,6 +68,7 @@ public class UniverseObjectSerializer : EngineTypeYamlSerializerBase<IUniverseOb
         foreach (IUniverseObject child in children)
             universeObject.AddChild(child);
 
+        ProgressionTracker.Set(isTrackingController ? .3f : ProgressionTracker.Progression, $"Created {name}");
         return universeObject;
     }
 
@@ -71,6 +76,9 @@ public class UniverseObjectSerializer : EngineTypeYamlSerializerBase<IUniverseOb
     {
         IUniverseObject universeObject = (IUniverseObject)value!;
 
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing universe object");
+
         emitter.Emit(new MappingStart());
 
         emitter.Emit(new Scalar(nameof(IUniverseObject.Name)));
@@ -91,6 +99,7 @@ public class UniverseObjectSerializer : EngineTypeYamlSerializerBase<IUniverseOb
         emitter.Emit(new Scalar(nameof(IUniverseObject.Children)));
         serializer(universeObject.Children.Where(c => !c.GetType().HasAttribute<IgnoreSerializationAttribute>()));
 
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serializing universe object");
         emitter.Emit(new MappingEnd());
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/SerializerInProgressException.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace Syntriax.Engine.Serializers.Yaml;
+
+[Serializable]
+public class SerializerInProgressException() : Exception("There's already a running deserialization in progress.");

Engine.Serializers/Engine.Serializers.Yaml/YamlSerializer.cs

@@ -2,7 +2,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 
+using Syntriax.Engine.Core;
 using Syntriax.Engine.Core.Serialization;
 
 using YamlDotNet.Serialization;
@@ -16,10 +18,14 @@ public class YamlSerializer : Core.Serialization.ISerializer
     private readonly YamlDotNet.Serialization.IDeserializer deserializer = null!;
 
     private readonly EntityRegistry entityRegistry = null!;
+    private readonly IProgressionTracker progressionTracker = null!;
+
+    private readonly System.Threading.Lock Lock = new();
 
     public YamlSerializer()
     {
         entityRegistry = new();
+        progressionTracker = new ProgressionTracker();
 
         SerializerBuilder serializerBuilder = new SerializerBuilder()
                 .WithNamingConvention(PascalCaseNamingConvention.Instance)
@@ -32,6 +38,7 @@ public class YamlSerializer : Core.Serialization.ISerializer
         {
             typeConverter.Serializer = this;
             typeConverter.EntityRegistry = entityRegistry;
+            typeConverter.ProgressionTracker = progressionTracker;
 
             deserializerBuilder = deserializerBuilder.WithTypeConverter(typeConverter);
             serializerBuilder = serializerBuilder.WithTypeConverter(typeConverter);
@@ -49,35 +56,87 @@ public class YamlSerializer : Core.Serialization.ISerializer
 
     public string Serialize(object instance)
     {
-        return serializer.Serialize(instance);
+        lock (Lock)
+        {
+            return serializer.Serialize(instance);
+        }
     }
 
-    public object Deserialize(string yaml)
+    public object Deserialize(string configuration)
     {
-        entityRegistry.Reset();
+        lock (Lock)
-        object result = deserializer.Deserialize(yaml)!;
+        {
-        entityRegistry.AssignAll();
+            entityRegistry.Reset();
-        return result;
+            object result = deserializer.Deserialize(configuration)!;
+            entityRegistry.AssignAll();
+            return result;
+        }
     }
 
-    public object Deserialize(string yaml, Type type)
+    public object Deserialize(string configuration, Type type)
     {
-        entityRegistry.Reset();
+        lock (Lock)
-        object result = deserializer.Deserialize(yaml, type)!;
+        {
-        entityRegistry.AssignAll();
+            entityRegistry.Reset();
-        return result;
+            object result = deserializer.Deserialize(configuration, type)!;
+            entityRegistry.AssignAll();
+            return result;
+        }
     }
 
-    public T Deserialize<T>(string yaml)
+    public T Deserialize<T>(string configuration)
     {
-        entityRegistry.Reset();
+        lock (Lock)
-        T result = deserializer.Deserialize<T>(yaml);
+        {
-        entityRegistry.AssignAll();
+            entityRegistry.Reset();
-        return result;
+            T result = deserializer.Deserialize<T>(configuration);
+            entityRegistry.AssignAll();
+            return result;
+        }
     }
 
-    internal object InternalDeserialize(string yaml, Type type)
+    public ProgressiveTask<object> DeserializeAsync(string configuration)
     {
-        return deserializer.Deserialize(yaml, type)!;
+        lock (Lock)
+        {
+            progressionTracker.Reset();
+            Task<object> task = Task.Run(() => Deserialize(configuration));
+            return new ProgressiveTask<object>(progressionTracker, task);
+        }
+    }
+
+    public ProgressiveTask<object> DeserializeAsync(string configuration, Type type)
+    {
+        lock (Lock)
+        {
+            progressionTracker.Reset();
+            Task<object> task = Task.Run(() => Deserialize(configuration, type));
+            return new ProgressiveTask<object>(progressionTracker, task);
+        }
+    }
+
+    public ProgressiveTask<T> DeserializeAsync<T>(string configuration)
+    {
+        lock (Lock)
+        {
+            progressionTracker.Reset();
+            Task<T> task = Task.Run(() => Deserialize<T>(configuration));
+            return new ProgressiveTask<T>(progressionTracker, task);
+        }
+    }
+
+    public ProgressiveTask<string> SerializeAsync(object instance)
+    {
+        lock (Lock)
+        {
+            progressionTracker.Reset();
+            Task<string> task = Task.Run(() => Serialize(instance));
+            return new ProgressiveTask<string>(progressionTracker, task);
+        }
+    }
+
+    internal object InternalDeserialize(string configuration, Type type)
+    {
+        return deserializer.Deserialize(configuration, type)!;
     }
 }