com.wallstop-studios.unity-helpers 2.0.1 → 2.0.3

package/Runtime/Core/Helper/Logging/UnityLogTagFormatter.cs

@@ -60,6 +60,9 @@ namespace WallstopStudios.UnityHelpers.Core.Helper.Logging
                 Func<string, object, string> formatter
             )>
         > _matchingDecorations = new();
+        private readonly Dictionary<string, (int priority, int index)> _decorationLookup = new(
+            StringComparer.OrdinalIgnoreCase
+        );
         private readonly StringBuilder _cachedStringBuilder = new();
         private readonly List<string> _cachedDecorators = new();
         private readonly HashSet<string> _appliedTags = new(StringComparer.OrdinalIgnoreCase);
@@ -379,89 +382,50 @@ namespace WallstopStudios.UnityHelpers.Core.Helper.Logging
             bool force = false
         )
         {
-            bool stopLooping = false;
-            foreach (
-                KeyValuePair<
-                    int,
-                    List<(
-                        string tag,
-                        bool editorOnly,
-                        Func<string, bool> predicate,
-                        Func<string, object, string> formatter
-                    )>
-                > entry in _matchingDecorations
-            )
+            if (_decorationLookup.TryGetValue(tag, out (int priority, int index) existing))
             {
-                for (int i = 0; i < entry.Value.Count; i++)
+                if (!force)
+                {
+                    return false;
+                }
+
+                if (existing.priority == priority)
                 {
-                    (
+                    List<(
                         string tag,
                         bool editorOnly,
                         Func<string, bool> predicate,
                         Func<string, object, string> formatter
-                    ) existingDecoration = entry.Value[i];
-                    if (
-                        !string.Equals(
-                            existingDecoration.tag,
-                            tag,
-                            StringComparison.OrdinalIgnoreCase
-                        )
-                    )
-                    {
-                        continue;
-                    }
-
-                    if (force)
-                    {
-                        if (priority != entry.Key)
-                        {
-                            entry.Value.RemoveAt(i);
-                            if (entry.Value.Count == 0)
-                            {
-                                _matchingDecorations.Remove(entry.Key);
-                            }
-
-                            stopLooping = true;
-                            break;
-                        }
+                    )> decorationsAtPriority = _matchingDecorations[priority];
 
-                        entry.Value[i] = (tag, editorOnly, predicate, format);
-                        return true;
-                    }
-                    return false;
+                    decorationsAtPriority[existing.index] = (tag, editorOnly, predicate, format);
+                    _decorationLookup[tag] = (priority, existing.index);
+                    return true;
                 }
 
-                if (stopLooping)
-                {
-                    break;
-                }
+                RemoveDecorationInternal(existing.priority, existing.index);
             }
 
-            if (
-                !_matchingDecorations.TryGetValue(
-                    priority,
-                    out List<(
-                        string tag,
-                        bool editorOnly,
-                        Func<string, bool> predicate,
-                        Func<string, object, string> formatter
-                    )> matchingDecorations
-                )
-            )
+            List<(
+                string tag,
+                bool editorOnly,
+                Func<string, bool> predicate,
+                Func<string, object, string> formatter
+            )> matchingDecorations;
+            if (!_matchingDecorations.TryGetValue(priority, out matchingDecorations))
             {
-                _matchingDecorations[priority] = new List<(
+                matchingDecorations = new List<(
                     string tag,
                     bool editorOnly,
                     Func<string, bool> predicate,
                     Func<string, object, string> formatter
-                )>
-                {
-                    (tag, editorOnly, predicate, format),
-                };
-                return true;
+                )>(1);
+                _matchingDecorations[priority] = matchingDecorations;
             }
 
+            int indexToInsert = matchingDecorations.Count;
             matchingDecorations.Add((tag, editorOnly, predicate, format));
+            _decorationLookup[tag] = (priority, indexToInsert);
             return true;
         }
 
@@ -481,35 +445,57 @@ namespace WallstopStudios.UnityHelpers.Core.Helper.Logging
             ) decoration
         )
         {
-            foreach (
-                KeyValuePair<
-                    int,
-                    List<(
-                        string tag,
-                        bool editorOnly,
-                        Func<string, bool> predicate,
-                        Func<string, object, string> formatter
-                    )>
-                > entry in _matchingDecorations
-            )
+            if (!_decorationLookup.TryGetValue(tag, out (int priority, int index) existing))
             {
-                for (int i = 0; i < entry.Value.Count; ++i)
-                {
-                    decoration = entry.Value[i];
-                    if (string.Equals(tag, decoration.tag, StringComparison.OrdinalIgnoreCase))
-                    {
-                        entry.Value.RemoveAt(i);
-                        if (entry.Value.Count == 0)
-                        {
-                            _matchingDecorations.Remove(entry.Key);
-                        }
-                        return true;
-                    }
-                }
+                decoration = default;
+                return false;
+            }
+
+            decoration = RemoveDecorationInternal(existing.priority, existing.index);
+            return true;
+        }
+
+        private (
+            string tag,
+            bool editorOnly,
+            Func<string, bool> predicate,
+            Func<string, object, string> formatter
+        ) RemoveDecorationInternal(int priority, int index)
+        {
+            List<(
+                string tag,
+                bool editorOnly,
+                Func<string, bool> predicate,
+                Func<string, object, string> formatter
+            )> decorationsAtPriority = _matchingDecorations[priority];
+
+            (
+                string tag,
+                bool editorOnly,
+                Func<string, bool> predicate,
+                Func<string, object, string> formatter
+            ) removed = decorationsAtPriority[index];
+
+            decorationsAtPriority.RemoveAt(index);
+            _decorationLookup.Remove(removed.tag);
+
+            for (int i = index; i < decorationsAtPriority.Count; ++i)
+            {
+                (
+                    string tag,
+                    bool editorOnly,
+                    Func<string, bool> predicate,
+                    Func<string, object, string> formatter
+                ) entry = decorationsAtPriority[i];
+                _decorationLookup[entry.tag] = (priority, i);
+            }
+
+            if (decorationsAtPriority.Count == 0)
+            {
+                _matchingDecorations.Remove(priority);
             }
 
-            decoration = default;
-            return false;
+            return removed;
         }
 
         [HideInCallstack]

package/Runtime/Tags/AttributesComponent.cs

@@ -48,7 +48,7 @@ namespace WallstopStudios.UnityHelpers.Tags
         /// </summary>
         public event Action<string, float, float> OnAttributeModified;
 
-        private readonly Dictionary<string, Func<object, Attribute>> _attributeFieldGetters;
+        private Dictionary<string, Func<object, Attribute>> _attributeFieldGetters;
         private readonly HashSet<EffectHandle> _effectHandles;
 
         [SiblingComponent]
@@ -62,7 +62,6 @@ namespace WallstopStudios.UnityHelpers.Tags
         /// </summary>
         protected AttributesComponent()
         {
-            _attributeFieldGetters = AttributeUtilities.GetOptimizedAttributeFields(GetType());
             _effectHandles = new HashSet<EffectHandle>();
         }
 
@@ -72,6 +71,7 @@ namespace WallstopStudios.UnityHelpers.Tags
         /// </summary>
         protected virtual void Awake()
         {
+            EnsureAttributeFieldGettersInitialized();
             this.AssignSiblingComponents();
             _effectHandler.Register(this);
         }
@@ -217,8 +217,9 @@ namespace WallstopStudios.UnityHelpers.Tags
             }
         }
 
-        private bool TryGetAttribute(string attributeName, out Attribute attribute)
+        protected bool TryGetAttribute(string attributeName, out Attribute attribute)
         {
+            EnsureAttributeFieldGettersInitialized();
             if (
                 !_attributeFieldGetters.TryGetValue(
                     attributeName,
@@ -233,5 +234,15 @@ namespace WallstopStudios.UnityHelpers.Tags
             attribute = getter(this);
             return true;
         }
+
+        protected void EnsureAttributeFieldGettersInitialized()
+        {
+            if (_attributeFieldGetters != null)
+            {
+                return;
+            }
+
+            _attributeFieldGetters = AttributeUtilities.GetOptimizedAttributeFields(GetType());
+        }
     }
 }

package/Tests/Runtime/Extensions/UnityLogTagFormatterEdgeTests.cs

@@ -256,5 +256,89 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             formatted = formatter.Log($"{"value":demo}", pretty: false);
             Assert.AreEqual("<P1>value</P1>", formatted);
         }
+
+        [Test]
+        public void ForceOverrideAtSamePriorityReplacesFormatter()
+        {
+            UnityLogTagFormatter formatter = new(createDefaultDecorators: false);
+
+            formatter.AddDecoration(
+                match: "demo",
+                format: value => $"<Initial>{value}</Initial>",
+                tag: "Demo",
+                priority: 3,
+                editorOnly: false,
+                force: true
+            );
+            formatter.AddDecoration(
+                match: "demo",
+                format: value => $"<Updated>{value}</Updated>",
+                tag: "Demo",
+                priority: 3,
+                editorOnly: false,
+                force: true
+            );
+
+            string formatted = formatter.Log($"{"value":demo}", pretty: false);
+            Assert.AreEqual("<Updated>value</Updated>", formatted);
+        }
+
+        [Test]
+        public void DuplicateTagWithoutForceReturnsFalse()
+        {
+            UnityLogTagFormatter formatter = new(createDefaultDecorators: false);
+
+            bool firstResult = formatter.AddDecoration(
+                match: "demo",
+                format: value => $"<Initial>{value}</Initial>",
+                tag: "Demo",
+                priority: 0,
+                editorOnly: false,
+                force: false
+            );
+            Assert.IsTrue(firstResult);
+
+            bool secondResult = formatter.AddDecoration(
+                match: "demo",
+                format: value => $"<Ignored>{value}</Ignored>",
+                tag: "Demo",
+                priority: 10,
+                editorOnly: false,
+                force: false
+            );
+            Assert.IsFalse(secondResult);
+
+            string formatted = formatter.Log($"{"value":demo}", pretty: false);
+            Assert.AreEqual("<Initial>value</Initial>", formatted);
+        }
+
+        [Test]
+        public void RemoveDecorationRemovesFormatter()
+        {
+            UnityLogTagFormatter formatter = new(createDefaultDecorators: false);
+
+            formatter.AddDecoration(
+                match: "demo",
+                format: value => $"<Removed>{value}</Removed>",
+                tag: "Demo",
+                priority: 0,
+                editorOnly: false,
+                force: true
+            );
+
+            (
+                string tag,
+                bool editorOnly,
+                Func<string, bool> predicate,
+                Func<string, object, string> formatterDelegate
+            ) removedDecoration;
+            bool removed = formatter.RemoveDecoration("Demo", out removedDecoration);
+
+            Assert.IsTrue(removed);
+            Assert.AreEqual("Demo", removedDecoration.tag);
+
+            string formatted = formatter.Log($"{"value":demo}", pretty: false);
+            Assert.AreEqual("value", formatted);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},