feat: async serializer methods

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();
-        object result = deserializer.Deserialize(yaml)!;
-        entityRegistry.AssignAll();
-        return result;
+        lock (Lock)
+        {
+            entityRegistry.Reset();
+            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();
-        object result = deserializer.Deserialize(yaml, type)!;
-        entityRegistry.AssignAll();
-        return result;
+        lock (Lock)
+        {
+            entityRegistry.Reset();
+            object result = deserializer.Deserialize(configuration, type)!;
+            entityRegistry.AssignAll();
+            return result;
+        }
     }
 
-    public T Deserialize<T>(string yaml)
+    public T Deserialize<T>(string configuration)
     {
-        entityRegistry.Reset();
-        T result = deserializer.Deserialize<T>(yaml);
-        entityRegistry.AssignAll();
-        return result;
+        lock (Lock)
+        {
+            entityRegistry.Reset();
+            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)!;
     }
 }