fix: 1. AsyncIO uses PathBuilders that already return to the pool, 2.…

… ObserverCollections only do actions synchronously
tinysnake · Oct 24, 2024 · c63bb22 · c63bb22
1 parent c54b74a
commit c63bb22
Show file tree

Hide file tree

Showing 7 changed files with 186 additions and 53 deletions.
diff --git a/Salvavida/Package/Runtime/AsyncIO.cs b/Salvavida/Package/Runtime/AsyncIO.cs
@@ -17,7 +17,7 @@ public abstract partial class AsyncIO : IDisposable
 
         public void QueueJob(AsyncJob job)
         {
-            var hashCode = job.PathBuilder.GetHashCode();
+            var hashCode = job.PathBuilder!.GetHashCode();
             if (_jobs.TryGetValue(hashCode, out var j))
             {
                 job.JoinJob(j);

diff --git a/Salvavida/Package/Runtime/AsyncJob.cs b/Salvavida/Package/Runtime/AsyncJob.cs
@@ -6,9 +6,9 @@ namespace Salvavida
 {
     public abstract class AsyncJob : INotifyCompletion
     {
-        protected AsyncJob(PathBuilder pathBuilder, CancellationToken token)
+        protected AsyncJob(IObjectPool<PathBuilder>.UsingScope pathScope, CancellationToken token)
         {
-            PathBuilder = pathBuilder;
+            _pathScope = pathScope;
             _token = token;
         }
 
@@ -18,11 +18,12 @@ protected AsyncJob(PathBuilder pathBuilder, CancellationToken token)
         private int _jobFinished;
         private int _completed;
         private AsyncJob? _joinedJob;
+        private IObjectPool<PathBuilder>.UsingScope _pathScope;
 
         public bool IsCompleted => _completed > 0;
         public bool JobFinished => _jobFinished > 0;
 
-        public PathBuilder PathBuilder { get; }
+        public PathBuilder? PathBuilder => _pathScope.Value;
 
         public void RunJob()
         {
@@ -49,6 +50,7 @@ public void SetComplete()
                 JoinedJobOnComplete(_joinedJob);
                 _joinedJob.SetComplete();
             }
+            _pathScope.Dispose();
         }
 
         public void OnCompleted(Action continuation)
@@ -72,8 +74,8 @@ public void JoinJob(AsyncJob job)
 
     public class AsyncVoidJob : AsyncJob
     {
-        public AsyncVoidJob(PathBuilder pathBuilder, Action action, CancellationToken token)
-            : base(pathBuilder, token)
+        public AsyncVoidJob(IObjectPool<PathBuilder>.UsingScope pathScope, Action action, CancellationToken token)
+            : base(pathScope, token)
         {
             _action = action ?? throw new ArgumentNullException(nameof(action));
         }
@@ -108,8 +110,8 @@ protected override void JoinedJobOnComplete(AsyncJob job)
 
     public class AsyncValueJob<T> : AsyncJob
     {
-        public AsyncValueJob(PathBuilder pathBuilder, Func<T> valueGetter, CancellationToken token)
-            : base(pathBuilder, token)
+        public AsyncValueJob(IObjectPool<PathBuilder>.UsingScope pathScope, Func<T> valueGetter, CancellationToken token)
+            : base(pathScope, token)
         {
             _valueGetter = valueGetter ?? throw new ArgumentNullException(nameof(valueGetter));
         }

diff --git a/Salvavida/Package/Runtime/ObservableArray.cs b/Salvavida/Package/Runtime/ObservableArray.cs
@@ -96,11 +96,14 @@ protected override void OnChildChanged(T child, string _)
             return CollectionChangeInfo<T?>.Add(_arr, 0);
         }
 
-        protected override void TrySaveSource(Serializer serializer, PathBuilder pathBuilder)
+        protected override void TrySaveSource(Serializer serializer, PathBuilder? pathBuilder)
         {
             if (string.IsNullOrEmpty(SvId))
                 throw new NullReferenceException(nameof(SvId));
-            serializer.SaveArray(_arr, pathBuilder);
+            if (pathBuilder == null)
+                serializer.FreshActionByPolicy(this, path => serializer.SaveArray(_arr, path));
+            else
+                serializer.SaveArray(_arr, pathBuilder);
         }
 
         public void Add(T? item) => throw new NotSupportedException();

diff --git a/Salvavida/Package/Runtime/ObservableCollection.cs b/Salvavida/Package/Runtime/ObservableCollection.cs
@@ -48,16 +48,19 @@ public void TrySave(Serializer? serializer, PathBuilder pathBuilder)
             _isDirty = false;
         }
 
-        protected abstract void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder pathBuilder);
+        protected abstract void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder? pathBuilder);
 
 
 
-        protected abstract void TrySaveSource(Serializer serializer, PathBuilder pathBuilder);
+        protected abstract void TrySaveSource(Serializer serializer, PathBuilder? pathBuilder);
 
 
-        protected void ClearCollection(Serializer serializer, PathBuilder pathBuilder)
+        protected void ClearCollection(Serializer serializer, PathBuilder? pathBuilder)
         {
-            serializer.DeleteAll(pathBuilder);
+            if (pathBuilder == null)
+                serializer.FreshDeleteAllByPolicy(this);
+            else
+                serializer.DeleteAll(pathBuilder);
         }
 
         void ISavable.SetParent(ISavable? parent)
@@ -130,9 +133,7 @@ protected void OnCollectionChange(CollectionChangeInfo<TElem?> e)
             {
                 if (SaveSeparately)
                 {
-                    using var action = serializer.BeginFreshAction(out var pathBuilder);
-                    this.GetSavePathAsSpan(pathBuilder);
-                    TrySaveSeparatelyByEvent(serializer, pathBuilder, e);
+                    TrySaveSeparatelyByEvent(serializer, null, e);
                 }
                 else
                 {
@@ -142,12 +143,12 @@ protected void OnCollectionChange(CollectionChangeInfo<TElem?> e)
             CollectionChanged?.Invoke(e);
         }
 
-        protected override void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder pathBuilder)
+        protected override void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder? pathBuilder)
         {
             TrySaveSeparatelyByEvent(serializer, pathBuilder, CreateSaveAllEvent());
         }
 
-        protected void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder pathBuilder, CollectionChangeInfo<TElem?> e)
+        protected void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder? pathBuilder, CollectionChangeInfo<TElem?> e)
         {
             if (!SaveSeparately)
                 throw new NotSupportedException();
@@ -157,7 +158,7 @@ protected void TrySaveSeparatelyByEvent(Serializer serializer, PathBuilder pathB
                 TrySaveItems(serializer, pathBuilder, e);
         }
 
-        protected virtual void TrySaveItems(Serializer serializer, PathBuilder pathBuilder, CollectionChangeInfo<TElem?> e)
+        protected virtual void TrySaveItems(Serializer serializer, PathBuilder? pathBuilder, CollectionChangeInfo<TElem?> e)
         {
             if (string.IsNullOrEmpty(SvId) || SvParent == null)
                 return;
@@ -181,21 +182,42 @@ protected virtual void TrySaveItems(Serializer serializer, PathBuilder pathBuild
             }
         }
 
-        protected void CollectionSave(Serializer serializer, PathBuilder path, TElem? oldItem, TElem? newItem, int startingIndex)
+        protected void CollectionSave(Serializer serializer, PathBuilder? path, TElem? oldItem, TElem? newItem, int startingIndex)
         {
             if (oldItem is ISavable old)
-                serializer.Delete(old, path, PathBuilder.Type.Collection);
+            {
+                if (path == null)
+                    serializer.FreshDeleteByPolicy(old);
+                else
+                    serializer.Delete(old, path, PathBuilder.Type.Collection);
+            }
             if (newItem is ISavable nuevo)
             {
 #if DEBUG
                 if (newItem is ISaveWithOrder swo && swo.SvOrder != startingIndex)
                     throw new Exception($"index mismatch, svOrder: {swo.SvOrder}, index: {startingIndex}");
 #endif
-                serializer.Save(nuevo, path, PathBuilder.Type.Collection);
+                if (path == null)
+                    serializer.FreshSaveByPolicy(nuevo);
+                else
+                    serializer.Save(nuevo, path, PathBuilder.Type.Collection);
+            }
+        }
+
+        protected void CollectionSave(Serializer serializer, PathBuilder? path, IList<TElem?> oldItems, IList<TElem?> newItems, int startingIndex)
+        {
+            if (path == null)
+            {
+                serializer.FreshActionByPolicy(this, pathBuilder =>
+                {
+                    CollectionSaveAction(serializer, pathBuilder, oldItems, newItems, startingIndex);
+                });
             }
+            else
+                CollectionSaveAction(serializer, path, oldItems, newItems, startingIndex);
         }
 
-        protected void CollectionSave(Serializer serializer, PathBuilder path, IList<TElem?> oldItems, IList<TElem?> newItems, int startingIndex)
+        private void CollectionSaveAction(Serializer serializer, PathBuilder path, IList<TElem?> oldItems, IList<TElem?> newItems, int startingIndex)
         {
             if (oldItems != null)
             {
@@ -224,20 +246,42 @@ protected void CollectionSave(Serializer serializer, PathBuilder path, IList<TEl
             }
         }
 
-        protected void ReplaceSave(Serializer serializer, PathBuilder pathBuilder, ISavable? oldItem, ISavable? newItem)
+        protected void ReplaceSave(Serializer serializer, PathBuilder? pathBuilder, ISavable? oldItem, ISavable? newItem)
         {
             if (oldItem != null)
             {
                 if (newItem == null || oldItem.SvId != newItem.SvId)
                 {
-                    serializer.Delete(oldItem, pathBuilder, PathBuilder.Type.Collection);
+                    if (pathBuilder == null)
+                        serializer.FreshDeleteAllByPolicy(oldItem);
+                    else
+                        serializer.Delete(oldItem, pathBuilder, PathBuilder.Type.Collection);
                 }
             }
             if (newItem != null)
-                serializer.Save(newItem, pathBuilder, PathBuilder.Type.Collection);
+            {
+                if (pathBuilder == null)
+                    serializer.FreshSaveByPolicy(newItem);
+                else
+                    serializer.Save(newItem, pathBuilder, PathBuilder.Type.Collection);
+            }
         }
 
-        protected void CollectionUpdateOrder(Serializer serializer, PathBuilder pathBuilder, IList<TElem?> items)
+        protected void CollectionUpdateOrder(Serializer serializer, PathBuilder? pathBuilder, IList<TElem?> items)
+        {
+            if (pathBuilder == null)
+            {
+                serializer.FreshActionByPolicy(this, path =>
+                {
+                    CollectionUpdateOrderAction(serializer, path, items);
+                });
+            }
+            else
+            {
+                CollectionUpdateOrder(serializer, pathBuilder, items);
+            }
+        }
+        protected void CollectionUpdateOrderAction(Serializer serializer, PathBuilder pathBuilder, IList<TElem?> items)
         {
             for (var i = 0; i < items.Count; i++)
             {

diff --git a/Salvavida/Package/Runtime/ObservableDictionary.cs b/Salvavida/Package/Runtime/ObservableDictionary.cs
@@ -115,7 +115,7 @@ protected override void OnChildChanged(TValue obj, string _)
         }
 
 
-        protected override void TrySaveItems(Serializer serializer, PathBuilder pathBuilder, CollectionChangeInfo<TValue?> e)
+        protected override void TrySaveItems(Serializer serializer, PathBuilder? pathBuilder, CollectionChangeInfo<TValue?> e)
         {
             switch (e.Action)
             {
@@ -139,19 +139,37 @@ protected override void TrySaveItems(Serializer serializer, PathBuilder pathBuil
                     throw new NotSupportedException();
             }
         }
-        private void KeyCollectionSave(Serializer serializer, PathBuilder pathBuilder, TValue value, bool isRemove)
+        private void KeyCollectionSave(Serializer serializer, PathBuilder? pathBuilder, TValue value, bool isRemove)
         {
             if (value is not ISavable sv)
                 throw new ArgumentException("values have to be implementations of ISavable");
             if (isRemove)
-                serializer.Delete(sv, pathBuilder, PathBuilder.Type.Collection);
+            {
+                if (pathBuilder == null)
+                    serializer.FreshDeleteByPolicy(sv);
+                else
+                    serializer.Delete(sv, pathBuilder, PathBuilder.Type.Collection);
+            }
             else
-                serializer.Save(sv, pathBuilder, PathBuilder.Type.Collection);
+            {
+                if (pathBuilder == null)
+                    serializer.FreshSaveByPolicy(sv);
+                else
+                    serializer.Save(sv, pathBuilder, PathBuilder.Type.Collection);
+            }
         }
-        private void KeyCollectionSave(Serializer serializer, PathBuilder pathBuilder, IList<TValue?> values, bool isRemove)
+        private void KeyCollectionSave(Serializer serializer, PathBuilder? pathBuilder, IList<TValue?> values, bool isRemove)
         {
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
+            if (pathBuilder == null)
+                serializer.FreshActionByPolicy(this, path => KeyCollectionSaveAction(serializer, path, values, isRemove));
+            else
+                KeyCollectionSaveAction(serializer, pathBuilder, values, isRemove);
+        }
+
+        private void KeyCollectionSaveAction(Serializer serializer, PathBuilder pathBuilder, IList<TValue?> values, bool isRemove)
+        {
             for (var i = 0; i < values.Count; i++)
             {
                 if (values[i] is not ISavable value)
@@ -163,11 +181,14 @@ private void KeyCollectionSave(Serializer serializer, PathBuilder pathBuilder, I
             }
         }
 
-        protected override void TrySaveSource(Serializer serializer, PathBuilder path)
+        protected override void TrySaveSource(Serializer serializer, PathBuilder? pathBuilder)
         {
             if (string.IsNullOrEmpty(SvId))
                 throw new NullReferenceException(nameof(SvId));
-            serializer.SaveDict(_dict, path);
+            if (pathBuilder == null)
+                serializer.FreshActionByPolicy(this, path => serializer.SaveDict(_dict, path));
+            else
+                serializer.SaveDict(_dict, pathBuilder);
         }
 
         public void Add(TKey key, TValue? value)

diff --git a/Salvavida/Package/Runtime/ObservableList.cs b/Salvavida/Package/Runtime/ObservableList.cs
@@ -93,7 +93,7 @@ protected override void OnChildChanged(T obj, string _)
             return CollectionChangeInfo<T?>.Add(_list, 0);
         }
 
-        protected override void TrySaveItems(Serializer serializer, PathBuilder path, CollectionChangeInfo<T?> e)
+        protected override void TrySaveItems(Serializer serializer, PathBuilder? path, CollectionChangeInfo<T?> e)
         {
             base.TrySaveItems(serializer, path, e);
             if (!_orderMatters)
@@ -111,14 +111,17 @@ protected override void TrySaveItems(Serializer serializer, PathBuilder path, Co
             }
         }
 
-        protected override void TrySaveSource(Serializer serializer, PathBuilder pathBuilder)
+        protected override void TrySaveSource(Serializer serializer, PathBuilder? pathBuilder)
         {
             if (string.IsNullOrEmpty(SvId))
                 throw new NullReferenceException(nameof(SvId));
-            serializer.SaveList(_list, pathBuilder);
+            if (pathBuilder == null)
+                serializer.FreshActionByPolicy(this, path => serializer.SaveList(_list, path));
+            else
+                serializer.SaveList(_list, pathBuilder);
         }
 
-        private void TryUpdateOrder(Serializer serializer, PathBuilder pathBuilder, int index)
+        private void TryUpdateOrder(Serializer serializer, PathBuilder? pathBuilder, int index)
         {
             var count = _list.Count - index;
             if (count <= 0)