Merge pull request #1086 from b-editor/resolvable-by-id

Enable Object Resolution by Id During Deserialization

src/Beutl.Core/Collections/HierarchicalList.cs

@@ -11,5 +11,10 @@ public HierarchicalList(IModifiableHierarchical parent)
         Detached += item => parent.RemoveChild(item);
     }
 
-    public IModifiableHierarchical Parent { get; }
+    public HierarchicalList()
+    {
+        ResetBehavior = ResetBehavior.Remove;
+    }
+
+    public IModifiableHierarchical? Parent { get; }
 }

src/Beutl.Core/CoreObject.cs

@@ -456,6 +456,12 @@ public virtual void Deserialize(ICoreSerializationContext context)
             Optional<object?> value = item.RouteDeserialize(context);
             if (value.HasValue)
             {
+                if (value.Value is IReference { IsNull: false } reference)
+                {
+                    context.Resolve(reference.Id,
+                        resolved => SetValue(item, reference.Resolved((CoreObject)resolved)));
+                }
+
                 SetValue(item, value.Value);
             }
         }

src/Beutl.Core/Hierarchy/Hierarchical.cs

@@ -5,6 +5,7 @@
 
 namespace Beutl;
 
+// TODO: 複数の親要素（参照元）を持てるようにする
 public abstract class Hierarchical : CoreObject, IHierarchical, IModifiableHierarchical
 {
     public static readonly CoreProperty<IHierarchical?> HierarchicalParentProperty;

src/Beutl.Core/JsonHelper.cs

@@ -87,6 +87,7 @@ public static void JsonRestore2(this ICoreSerializable serializable, string file
             using (ThreadLocalSerializationContext.Enter(context))
             {
                 serializable.Deserialize(context);
+                context.AfterDeserialized(serializable);
             }
         }
     }

src/Beutl.Core/OptionalJsonConverter.cs

@@ -45,6 +45,7 @@ public override bool CanConvert(Type typeToConvert)
                         using (ThreadLocalSerializationContext.Enter(context))
                         {
                             serializable.Deserialize(context);
+                            context.AfterDeserialized(serializable);
                         }
 
                         instance = serializable;

src/Beutl.Core/ProjectItemContainer.cs

@@ -93,7 +93,6 @@ public bool TryGetOrCreateItem(string file, [NotNullWhen(true)] out ProjectItem?
 
     public void Add(ProjectItem item)
     {
-        _app.Items.Add(item);
         foreach (WeakReference<ProjectItem> wref in _items)
         {
             if (!wref.TryGetTarget(out _))

src/Beutl.Core/Reference.cs

@@ -0,0 +1,83 @@
+namespace Beutl;
+
+public interface IReference
+{
+    Guid Id { get; }
+
+    CoreObject? Value { get; }
+
+    bool IsNull { get; }
+
+    Type ObjectType { get; }
+
+    IReference Resolved(CoreObject obj);
+}
+
+public readonly struct Reference<TObject> : IEquatable<Reference<TObject>>, IReference
+    where TObject : notnull, CoreObject
+{
+    private readonly TObject? _value;
+    private readonly Guid _id;
+
+    public Reference(Guid id) : this(id, null)
+    {
+    }
+
+    public Reference(TObject value) : this(value.Id, value)
+    {
+    }
+
+    public Reference(Guid id, TObject? value)
+    {
+        _id = id;
+        _value = value;
+    }
+
+    public Reference()
+    {
+    }
+
+    public Guid Id => _value?.Id ?? _id;
+
+    public TObject? Value => _value;
+
+    public bool IsNull => _id == Guid.Empty;
+
+    CoreObject? IReference.Value => Value;
+
+    Type IReference.ObjectType => typeof(TObject);
+
+    public Reference<TObject> Resolved(TObject obj)
+    {
+        return new Reference<TObject>(obj);
+    }
+
+    IReference IReference.Resolved(CoreObject obj)
+    {
+        return Resolved((TObject)obj);
+    }
+
+    public void Deconstruct(out Guid Id, out TObject? Value)
+    {
+        Id = this.Id;
+        Value = this.Value;
+    }
+
+    public bool Equals(Reference<TObject> other) => Id.Equals(other.Id);
+
+    public override bool Equals(object? obj) => obj is Reference<TObject> other && Equals(other);
+
+    public override int GetHashCode() => HashCode.Combine(_value, _id);
+
+    public static implicit operator Guid(Reference<TObject> reference) => reference.Id;
+
+    public static implicit operator Reference<TObject>(Guid id) => new(id);
+
+    public static implicit operator TObject?(Reference<TObject> reference) => reference.Value;
+
+    public static implicit operator Reference<TObject>(TObject value) => new(value.Id, value);
+
+    public static bool operator ==(Reference<TObject> left, Reference<TObject> right) => left.Equals(right);
+
+    public static bool operator !=(Reference<TObject> left, Reference<TObject> right) => !left.Equals(right);
+}

src/Beutl.Core/Serialization/CoreSerializableJsonConverter.cs

@@ -26,6 +26,7 @@ public sealed class CoreSerializableJsonConverter : JsonConverter<ICoreSerializa
                 using (ThreadLocalSerializationContext.Enter(context))
                 {
                     instance.Deserialize(context);
+                    context.AfterDeserialized(instance);
                 }
 
                 return instance;

src/Beutl.Core/Serialization/ICoreSerializationContext.cs

@@ -15,4 +15,6 @@ public interface ICoreSerializationContext
     bool Contains(string name);
 
     void Populate(string name, ICoreSerializable obj);
+
+    void Resolve(Guid id, Action<ICoreSerializable> callback);
 }

src/Beutl.Core/Serialization/JsonSerializationContext.Deserialize.cs

@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -25,7 +26,8 @@ private static void DeserializeArray(
             else
             {
                 string name = index.ToString();
-                output.Add(Deserialize(item, elementType, name, new RelaySerializationErrorNotifier(errorNotifier, name), parent));
+                output.Add(Deserialize(item, elementType, name,
+                    new RelaySerializationErrorNotifier(errorNotifier, name), parent));
             }
 
             index++;
@@ -78,6 +80,7 @@ private static void DeserializeArray(
                         if (Activator.CreateInstance(actualType) is ICoreSerializable instance)
                         {
                             instance.Deserialize(context);
+                            context.AfterDeserialized(instance);
 
                             return instance;
                         }
@@ -99,6 +102,12 @@ private static void DeserializeArray(
                     return ArrayTypeHelpers.ConvertArrayType(output, baseType, elementType);
                 }
             }
+            else if (node is JsonValue jsonValue
+                     && jsonValue.TryGetValue(out Guid id)
+                     && baseType.IsAssignableTo(typeof(IReference)))
+            {
+                return Activator.CreateInstance(baseType, id);
+            }
         }
 
         ISerializationErrorNotifier? captured = LocalSerializationErrorNotifier.Current;

src/Beutl.Core/Serialization/JsonSerializationContext.Serialize.cs

@@ -36,6 +36,10 @@ public partial class JsonSerializationContext
 
             return obj;
         }
+        else if (value is IReference reference)
+        {
+            return reference.Id;
+        }
         else if (value is JsonNode jsonNode)
         {
             return jsonNode;
@@ -115,7 +119,7 @@ public void SetValue<T>(string name, T? value)
         else
         {
             Type actualType = value.GetType();
-            if (value is ICoreSerializable or IEnumerable)
+            if (value is ICoreSerializable or IEnumerable or IReference)
             {
                 _json[name] = Serialize(name, value, actualType, typeof(T), ErrorNotifier, this);
             }

src/Beutl.Core/Serialization/JsonSerializationContext.cs

@@ -1,21 +1,31 @@
-using System.Text.Json.Nodes;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Nodes;
 
 namespace Beutl.Serialization;
 
 public partial class JsonSerializationContext(
-    Type ownerType, ISerializationErrorNotifier errorNotifier,
-    ICoreSerializationContext? parent = null, JsonObject? json = null)
+    Type ownerType,
+    ISerializationErrorNotifier errorNotifier,
+    ICoreSerializationContext? parent = null,
+    JsonObject? json = null)
     : IJsonSerializationContext
 {
     public readonly Dictionary<string, (Type DefinedType, Type ActualType)> _knownTypes = [];
+    private List<(Guid, Action<ICoreSerializable>)>? _resolvers;
+    private Dictionary<Guid, ICoreSerializable>? _objects;
     private readonly JsonObject _json = json ?? [];
 
     public ICoreSerializationContext? Parent { get; } = parent;
 
+    public JsonSerializationContext Root => IsRoot ? this : (Parent as JsonSerializationContext)!.Root;
+
     public CoreSerializationMode Mode => CoreSerializationMode.ReadWrite;
 
     public Type OwnerType { get; } = ownerType;
 
+    [MemberNotNullWhen(false, nameof(Parent))]
+    public bool IsRoot => Parent == null;
+
     public ISerializationErrorNotifier ErrorNotifier { get; } = errorNotifier;
 
     public JsonObject GetJsonObject()
@@ -57,6 +67,62 @@ public void Populate(string name, ICoreSerializable obj)
         }
     }
 
+    public void AfterDeserialized(ICoreSerializable obj)
+    {
+        if (obj is CoreObject coreObject)
+        {
+            SetObjectAndId(coreObject);
+
+            if (IsRoot)
+            {
+                // Resolve references
+                if (_resolvers == null)
+                    return;
+
+                for (int i = _resolvers.Count - 1; i >= 0; i--)
+                {
+                    var (id, callback) = _resolvers[i];
+                    if (_objects.TryGetValue(id, out var resolved))
+                    {
+                        callback(resolved);
+                    }
+
+                    _resolvers.RemoveAt(i);
+                }
+
+                // TODO: アプリケーション全体から解決できるようになれば、
+                // ここにそのコードを追加する。
+            }
+        }
+    }
+
+    [MemberNotNull(nameof(_objects))]
+    private void SetObjectAndId(CoreObject coreObject)
+    {
+        if (IsRoot)
+        {
+            _objects ??= new();
+            _objects[coreObject.Id] = coreObject;
+        }
+        else
+        {
+            Root.SetObjectAndId(coreObject);
+        }
+    }
+
+    public void Resolve(Guid id, Action<ICoreSerializable> callback)
+    {
+        if (IsRoot)
+        {
+            _resolvers ??= new();
+            _resolvers.Add((id, callback));
+        }
+        else
+        {
+            Parent.Resolve(id, callback);
+        }
+    }
+
     public bool Contains(string name)
     {
         return _json.ContainsKey(name);

src/Beutl.Engine/Animation/AnimationSerializer.cs

@@ -42,6 +42,7 @@ internal static class AnimationSerializer
                 using (ThreadLocalSerializationContext.Enter(innerContext))
                 {
                     animation.Deserialize(innerContext);
+                    innerContext.AfterDeserialized(animation);
                 }
                 return animation;
             }

src/Beutl.Engine/Converters/BrushJsonConverter.cs

@@ -30,6 +30,7 @@ public override IBrush Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
                 using (ThreadLocalSerializationContext.Enter(context))
                 {
                     instance.Deserialize(context);
+                    context.AfterDeserialized(instance);
                 }
 
                 return brush;

src/Beutl.Engine/Converters/KeyFrameJsonConverter.cs

@@ -57,6 +57,7 @@ public override IKeyFrame Read(ref Utf8JsonReader reader, Type typeToConvert, Js
                 using (ThreadLocalSerializationContext.Enter(context))
                 {
                     instance.Deserialize(context);
+                    context.AfterDeserialized(instance);
                 }
 
                 return instance;

src/Beutl.Engine/Converters/PenJsonConverter.cs

@@ -26,6 +26,7 @@ public override IPen Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSer
             using (ThreadLocalSerializationContext.Enter(context))
             {
                 pen.Deserialize(context);
+                context.AfterDeserialized(pen);
             }
 
             return pen;

src/Beutl.Engine/Converters/TransformJsonConverter.cs

@@ -30,6 +30,7 @@ public override ITransform Read(ref Utf8JsonReader reader, Type typeToConvert, J
                 using (ThreadLocalSerializationContext.Enter(context))
                 {
                     instance.Deserialize(context);
+                    context.AfterDeserialized(instance);
                 }
 
                 return transform;

src/Beutl.ProjectSystem/NodeTree/Node.cs

@@ -450,6 +450,7 @@ public override void Deserialize(ICoreSerializationContext context)
                         using (ThreadLocalSerializationContext.Enter(innerContext))
                         {
                             serializable.Deserialize(innerContext);
+                            innerContext.AfterDeserialized(serializable);
                         }
                     }
                 }

src/Beutl.ProjectSystem/NodeTree/Nodes/Group/GroupInput.cs

@@ -95,6 +95,7 @@ public override void Deserialize(ICoreSerializationContext context)
                         using (ThreadLocalSerializationContext.Enter(innerContext))
                         {
                             serializable.Deserialize(innerContext);
+                            innerContext.AfterDeserialized(serializable);
                         }
                     }
 

src/Beutl.ProjectSystem/NodeTree/Nodes/Group/GroupNode.cs

@@ -337,6 +337,7 @@ public override void Deserialize(ICoreSerializationContext context)
                     using (ThreadLocalSerializationContext.Enter(innerContext))
                     {
                         nodeItem.Deserialize(innerContext);
+                        innerContext.AfterDeserialized(nodeItem);
                     }
 
                     ((NodeItem)nodeItem).LocalId = index;

src/Beutl.ProjectSystem/NodeTree/Nodes/Group/GroupOutput.cs

@@ -95,6 +95,7 @@ public override void Deserialize(ICoreSerializationContext context)
                         using (ThreadLocalSerializationContext.Enter(innerContext))
                         {
                             serializable.Deserialize(innerContext);
+                            innerContext.AfterDeserialized(serializable);
                         }
                     }
 

src/Beutl.ProjectSystem/NodeTree/Nodes/LayerInputNode.cs

@@ -160,6 +160,7 @@ public override void Deserialize(ICoreSerializationContext context)
                         using (ThreadLocalSerializationContext.Enter(innerContext))
                         {
                             serializable.Deserialize(innerContext);
+                            innerContext.AfterDeserialized(serializable);
                         }
                     }