binding references done

LEGO · Jan 30, 2025 · 6816cd1 · 6816cd1
1 parent fedf798
commit 6816cd1
Show file tree

Hide file tree

Showing 13 changed files with 312 additions and 82 deletions.
diff --git a/src/LEGO.AsyncAPI.Readers/V2/AsyncApiChannelBindingDeserializer.cs b/src/LEGO.AsyncAPI.Readers/V2/AsyncApiChannelBindingDeserializer.cs
@@ -15,7 +15,7 @@ internal static AsyncApiBindings<IChannelBinding> LoadChannelBindings(ParseNode
             var pointer = mapNode.GetReferencePointer();
             if (pointer != null)
             {
-                return mapNode.GetReferencedObject<AsyncApiBindings<IChannelBinding>>(ReferenceType.ChannelBindings, pointer);
+                return new AsyncApiBindingsReference<IChannelBinding>(pointer);
             }
 
             var channelBindings = new AsyncApiBindings<IChannelBinding>();

diff --git a/src/LEGO.AsyncAPI.Readers/V2/AsyncApiComponentsDeserializer.cs b/src/LEGO.AsyncAPI.Readers/V2/AsyncApiComponentsDeserializer.cs
@@ -19,10 +19,10 @@ internal static partial class AsyncApiV2Deserializer
             { "correlationIds", (a, n) => a.CorrelationIds = n.CreateMap(LoadCorrelationId) },
             { "operationTraits", (a, n) => a.OperationTraits = n.CreateMap(LoadOperationTrait) },
             { "messageTraits", (a, n) => a.MessageTraits = n.CreateMap(LoadMessageTrait) },
-            { "serverBindings", (a, n) => a.ServerBindings = n.CreateMapWithReference(ReferenceType.ServerBindings, LoadServerBindings) },
-            { "channelBindings", (a, n) => a.ChannelBindings = n.CreateMapWithReference(ReferenceType.ChannelBindings, LoadChannelBindings) },
-            { "operationBindings", (a, n) => a.OperationBindings = n.CreateMapWithReference(ReferenceType.OperationBindings, LoadOperationBindings) },
-            { "messageBindings", (a, n) => a.MessageBindings = n.CreateMapWithReference(ReferenceType.MessageBindings, LoadMessageBindings) },
+            { "serverBindings", (a, n) => a.ServerBindings = n.CreateMap(LoadServerBindings) },
+            { "channelBindings", (a, n) => a.ChannelBindings = n.CreateMap(LoadChannelBindings) },
+            { "operationBindings", (a, n) => a.OperationBindings = n.CreateMap(LoadOperationBindings) },
+            { "messageBindings", (a, n) => a.MessageBindings = n.CreateMap(LoadMessageBindings) },
         };
 
         private static PatternFieldMap<AsyncApiComponents> componentsPatternFields =

diff --git a/src/LEGO.AsyncAPI.Readers/V2/AsyncApiMessageBindingDeserializer.cs b/src/LEGO.AsyncAPI.Readers/V2/AsyncApiMessageBindingDeserializer.cs
@@ -12,9 +12,13 @@ internal static partial class AsyncApiV2Deserializer
         internal static AsyncApiBindings<IMessageBinding> LoadMessageBindings(ParseNode node)
         {
             var mapNode = node.CheckMapNode("messageBindings");
+            var pointer = mapNode.GetReferencePointer();
+            if (pointer != null)
+            {
+                return new AsyncApiBindingsReference<IMessageBinding>(pointer);
+            }
 
             var messageBindings = new AsyncApiBindings<IMessageBinding>();
-
             foreach (var property in mapNode)
             {
                 var messageBinding = LoadMessageBinding(property);

diff --git a/src/LEGO.AsyncAPI.Readers/V2/AsyncApiOperationBindingDeserializer.cs b/src/LEGO.AsyncAPI.Readers/V2/AsyncApiOperationBindingDeserializer.cs
@@ -12,9 +12,13 @@ internal static partial class AsyncApiV2Deserializer
         internal static AsyncApiBindings<IOperationBinding> LoadOperationBindings(ParseNode node)
         {
             var mapNode = node.CheckMapNode("operationBindings");
+            var pointer = mapNode.GetReferencePointer();
+            if (pointer != null)
+            {
+                return new AsyncApiBindingsReference<IOperationBinding>(pointer);
+            }
 
             var operationBindings = new AsyncApiBindings<IOperationBinding>();
-
             foreach (var property in mapNode)
             {
                 var operationBinding = LoadOperationBinding(property);

diff --git a/src/LEGO.AsyncAPI.Readers/V2/AsyncApiServerBindingDeserializer.cs b/src/LEGO.AsyncAPI.Readers/V2/AsyncApiServerBindingDeserializer.cs
@@ -15,7 +15,7 @@ internal static AsyncApiBindings<IServerBinding> LoadServerBindings(ParseNode no
             var pointer = mapNode.GetReferencePointer();
             if (pointer != null)
             {
-                return mapNode.GetReferencedObject<AsyncApiBindings<IServerBinding>>(ReferenceType.ServerBindings, pointer);
+                return new AsyncApiBindingsReference<IServerBinding>(pointer);
             }
 
             var serverBindings = new AsyncApiBindings<IServerBinding>();

diff --git a/src/LEGO.AsyncAPI/Models/AsyncApiBinding.cs b/src/LEGO.AsyncAPI/Models/AsyncApiBinding.cs
@@ -4,18 +4,13 @@ namespace LEGO.AsyncAPI.Bindings
 {
     using System;
     using System.Collections.Generic;
-    using LEGO.AsyncAPI.Models;
     using LEGO.AsyncAPI.Models.Interfaces;
     using LEGO.AsyncAPI.Writers;
 
     public abstract class AsyncApiBinding : IBinding
     {
         public abstract string BindingKey { get; }
 
-        public bool UnresolvedReference { get; set; }
-
-        public AsyncApiReference Reference { get; set; }
-
         public IDictionary<string, IAsyncApiExtension> Extensions { get; set; } = new Dictionary<string, IAsyncApiExtension>();
 
         public string BindingVersion { get; set; }
@@ -27,12 +22,6 @@ public void SerializeV2(IAsyncApiWriter writer)
                 throw new ArgumentNullException(nameof(writer));
             }
 
-            if (this.Reference != null && !writer.GetSettings().ShouldInlineReference(this.Reference))
-            {
-                this.Reference.SerializeV2(writer);
-                return;
-            }
-
             this.SerializeProperties(writer);
         }
 

diff --git a/src/LEGO.AsyncAPI/Models/AsyncApiBindings{TBinding}.cs b/src/LEGO.AsyncAPI/Models/AsyncApiBindings{TBinding}.cs
@@ -3,39 +3,17 @@
 namespace LEGO.AsyncAPI.Models
 {
     using System;
+    using System.Collections;
     using System.Collections.Generic;
     using LEGO.AsyncAPI.Models.Interfaces;
     using LEGO.AsyncAPI.Writers;
 
-    public class AsyncApiBindings<TBinding> : Dictionary<string, TBinding>, IAsyncApiReferenceable
+    public class AsyncApiBindings<TBinding> : IDictionary<string, TBinding>, IAsyncApiSerializable
         where TBinding : IBinding
     {
-        public bool UnresolvedReference { get; set; }
+        private Dictionary<string, TBinding> inner = new Dictionary<string, TBinding>();
 
-        public AsyncApiReference Reference { get; set; }
-
-        public void Add(TBinding binding)
-        {
-            this[binding.BindingKey] = binding;
-        }
-
-        public void SerializeV2(IAsyncApiWriter writer)
-        {
-            if (writer is null)
-            {
-                throw new ArgumentNullException(nameof(writer));
-            }
-
-            if (this.Reference != null && !writer.GetSettings().ShouldInlineReference(this.Reference))
-            {
-                this.Reference.SerializeV2(writer);
-                return;
-            }
-
-            this.SerializeV2WithoutReference(writer);
-        }
-
-        public void SerializeV2WithoutReference(IAsyncApiWriter writer)
+        public virtual void SerializeV2(IAsyncApiWriter writer)
         {
             if (writer is null)
             {
@@ -56,5 +34,79 @@ public void SerializeV2WithoutReference(IAsyncApiWriter writer)
 
             writer.WriteEndObject();
         }
+
+        public virtual void Add(TBinding binding)
+        {
+            this[binding.BindingKey] = binding;
+        }
+
+        public virtual TBinding this[string key]
+        {
+            get => inner[key];
+            set => inner[key] = value;
+        }
+
+        public virtual ICollection<string> Keys => inner.Keys;
+
+        public virtual ICollection<TBinding> Values => inner.Values;
+
+        public virtual int Count => inner.Count;
+
+        public virtual bool IsReadOnly => ((IDictionary<string, TBinding>)inner).IsReadOnly;
+
+        public virtual void Add(string key, TBinding value)
+        {
+            inner.Add(key, value);
+        }
+
+        public virtual bool ContainsKey(string key)
+        {
+            return inner.ContainsKey(key);
+        }
+
+        public virtual bool Remove(string key)
+        {
+            return inner.Remove(key);
+        }
+
+        public virtual bool TryGetValue(string key, out TBinding value)
+        {
+            return inner.TryGetValue(key, out value);
+        }
+
+        public virtual void Add(KeyValuePair<string, TBinding> item)
+        {
+            ((IDictionary<string, TBinding>)inner).Add(item);
+        }
+
+        public virtual void Clear()
+        {
+            inner.Clear();
+        }
+
+        public virtual bool Contains(KeyValuePair<string, TBinding> item)
+        {
+            return ((IDictionary<string, TBinding>)inner).Contains(item);
+        }
+
+        public virtual void CopyTo(KeyValuePair<string, TBinding>[] array, int arrayIndex)
+        {
+            ((IDictionary<string, TBinding>)inner).CopyTo(array, arrayIndex);
+        }
+
+        public virtual bool Remove(KeyValuePair<string, TBinding> item)
+        {
+            return ((IDictionary<string, TBinding>)inner).Remove(item);
+        }
+
+        public virtual IEnumerator<KeyValuePair<string, TBinding>> GetEnumerator()
+        {
+            return inner.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return inner.GetEnumerator();
+        }
     }
 }
diff --git a/src/LEGO.AsyncAPI/Models/AsyncApiComponents.cs b/src/LEGO.AsyncAPI/Models/AsyncApiComponents.cs
@@ -290,11 +290,9 @@ public void SerializeV2(IAsyncApiWriter writer)
                 this.ServerBindings,
                 (w, key, component) =>
                 {
-                    if (component.Reference != null &&
-                        component.Reference.Type == ReferenceType.ServerBindings &&
-                        component.Reference.FragmentId == key)
+                    if (component is AsyncApiBindingsReference<IServerBinding> reference)
                     {
-                        component.SerializeV2WithoutReference(w);
+                        reference.SerializeV2(w);
                     }
                     else
                     {
@@ -308,11 +306,9 @@ public void SerializeV2(IAsyncApiWriter writer)
                 this.ChannelBindings,
                 (w, key, component) =>
                 {
-                    if (component.Reference != null &&
-                        component.Reference.Type == ReferenceType.ChannelBindings &&
-                        component.Reference.FragmentId == key)
+                    if (component is AsyncApiBindingsReference<IChannelBinding> reference)
                     {
-                        component.SerializeV2WithoutReference(w);
+                        reference.SerializeV2(w);
                     }
                     else
                     {
@@ -326,11 +322,9 @@ public void SerializeV2(IAsyncApiWriter writer)
                 this.OperationBindings,
                 (w, key, component) =>
                 {
-                    if (component.Reference != null &&
-                        component.Reference.Type == ReferenceType.OperationBindings &&
-                        component.Reference.FragmentId == key)
+                    if (component is AsyncApiBindingsReference<IOperationBinding> reference)
                     {
-                        component.SerializeV2WithoutReference(w);
+                        reference.SerializeV2(w);
                     }
                     else
                     {
@@ -344,11 +338,9 @@ public void SerializeV2(IAsyncApiWriter writer)
                 this.MessageBindings,
                 (w, key, component) =>
                 {
-                    if (component.Reference != null &&
-                        component.Reference.Type == ReferenceType.MessageBindings &&
-                        component.Reference.FragmentId == key)
+                    if (component is AsyncApiBindingsReference<IMessageBinding> reference)
                     {
-                        component.SerializeV2WithoutReference(w);
+                        reference.SerializeV2(w);
                     }
                     else
                     {