com.wallstop-studios.unity-helpers 2.0.0 → 2.0.2

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/Core/Serialization/ProtobufUnitySurrogates.cs

@@ -15,10 +15,9 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         [ProtoMember(2)]
         public float y;
 
-        public static implicit operator Vector2Surrogate(Vector2 v) =>
-            new Vector2Surrogate { x = v.x, y = v.y };
+        public static implicit operator Vector2Surrogate(Vector2 v) => new() { x = v.x, y = v.y };
 
-        public static implicit operator Vector2(Vector2Surrogate s) => new Vector2(s.x, s.y);
+        public static implicit operator Vector2(Vector2Surrogate s) => new(s.x, s.y);
     }
 
     [ProtoContract]
@@ -34,14 +33,14 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public float z;
 
         public static implicit operator Vector3Surrogate(Vector3 v) =>
-            new Vector3Surrogate
+            new()
             {
                 x = v.x,
                 y = v.y,
                 z = v.z,
             };
 
-        public static implicit operator Vector3(Vector3Surrogate s) => new Vector3(s.x, s.y, s.z);
+        public static implicit operator Vector3(Vector3Surrogate s) => new(s.x, s.y, s.z);
     }
 
     [ProtoContract]
@@ -60,7 +59,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public float w;
 
         public static implicit operator QuaternionSurrogate(Quaternion q) =>
-            new QuaternionSurrogate
+            new()
             {
                 x = q.x,
                 y = q.y,
@@ -69,7 +68,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
             };
 
         public static implicit operator Quaternion(QuaternionSurrogate s) =>
-            new Quaternion(s.x, s.y, s.z, s.w);
+            new(s.x, s.y, s.z, s.w);
     }
 
     [ProtoContract]
@@ -88,7 +87,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public float a;
 
         public static implicit operator ColorSurrogate(Color c) =>
-            new ColorSurrogate
+            new()
             {
                 r = c.r,
                 g = c.g,
@@ -96,7 +95,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
                 a = c.a,
             };
 
-        public static implicit operator Color(ColorSurrogate s) => new Color(s.r, s.g, s.b, s.a);
+        public static implicit operator Color(ColorSurrogate s) => new(s.r, s.g, s.b, s.a);
     }
 
     [ProtoContract]
@@ -115,7 +114,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public byte a;
 
         public static implicit operator Color32Surrogate(Color32 c) =>
-            new Color32Surrogate
+            new()
             {
                 r = c.r,
                 g = c.g,
@@ -123,8 +122,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
                 a = c.a,
             };
 
-        public static implicit operator Color32(Color32Surrogate s) =>
-            new Color32(s.r, s.g, s.b, s.a);
+        public static implicit operator Color32(Color32Surrogate s) => new(s.r, s.g, s.b, s.a);
     }
 
     [ProtoContract]
@@ -143,7 +141,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public float height;
 
         public static implicit operator RectSurrogate(Rect r) =>
-            new RectSurrogate
+            new()
             {
                 x = r.x,
                 y = r.y,
@@ -151,8 +149,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
                 height = r.height,
             };
 
-        public static implicit operator Rect(RectSurrogate s) =>
-            new Rect(s.x, s.y, s.width, s.height);
+        public static implicit operator Rect(RectSurrogate s) => new(s.x, s.y, s.width, s.height);
     }
 
     [ProtoContract]
@@ -171,7 +168,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public int height;
 
         public static implicit operator RectIntSurrogate(RectInt r) =>
-            new RectIntSurrogate
+            new()
             {
                 x = r.x,
                 y = r.y,
@@ -180,7 +177,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
             };
 
         public static implicit operator RectInt(RectIntSurrogate s) =>
-            new RectInt(s.x, s.y, s.width, s.height);
+            new(s.x, s.y, s.width, s.height);
     }
 
     [ProtoContract]
@@ -205,7 +202,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public float sz;
 
         public static implicit operator BoundsSurrogate(Bounds b) =>
-            new BoundsSurrogate
+            new()
             {
                 cx = b.center.x,
                 cy = b.center.y,
@@ -216,7 +213,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
             };
 
         public static implicit operator Bounds(BoundsSurrogate s) =>
-            new Bounds(new Vector3(s.cx, s.cy, s.cz), new Vector3(s.sx, s.sy, s.sz));
+            new(new Vector3(s.cx, s.cy, s.cz), new Vector3(s.sx, s.sy, s.sz));
     }
 
     [ProtoContract]
@@ -241,7 +238,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public int sz;
 
         public static implicit operator BoundsIntSurrogate(BoundsInt b) =>
-            new BoundsIntSurrogate
+            new()
             {
                 px = b.position.x,
                 py = b.position.y,
@@ -252,7 +249,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
             };
 
         public static implicit operator BoundsInt(BoundsIntSurrogate s) =>
-            new BoundsInt(new Vector3Int(s.px, s.py, s.pz), new Vector3Int(s.sx, s.sy, s.sz));
+            new(new Vector3Int(s.px, s.py, s.pz), new Vector3Int(s.sx, s.sy, s.sz));
     }
 
     [ProtoContract]
@@ -265,10 +262,9 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public int y;
 
         public static implicit operator Vector2IntSurrogate(Vector2Int v) =>
-            new Vector2IntSurrogate { x = v.x, y = v.y };
+            new() { x = v.x, y = v.y };
 
-        public static implicit operator Vector2Int(Vector2IntSurrogate s) =>
-            new Vector2Int(s.x, s.y);
+        public static implicit operator Vector2Int(Vector2IntSurrogate s) => new(s.x, s.y);
     }
 
     [ProtoContract]
@@ -284,15 +280,14 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
         public int z;
 
         public static implicit operator Vector3IntSurrogate(Vector3Int v) =>
-            new Vector3IntSurrogate
+            new()
             {
                 x = v.x,
                 y = v.y,
                 z = v.z,
             };
 
-        public static implicit operator Vector3Int(Vector3IntSurrogate s) =>
-            new Vector3Int(s.x, s.y, s.z);
+        public static implicit operator Vector3Int(Vector3IntSurrogate s) => new(s.x, s.y, s.z);
     }
 
     [ProtoContract]
@@ -309,7 +304,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
 
         [Obsolete("Obsolete")]
         public static implicit operator ResolutionSurrogate(Resolution r) =>
-            new ResolutionSurrogate
+            new()
             {
                 width = r.width,
                 height = r.height,
@@ -318,7 +313,7 @@ namespace WallstopStudios.UnityHelpers.Core.Serialization
 
         public static implicit operator Resolution(ResolutionSurrogate s)
         {
-            Resolution r = new Resolution { width = s.width, height = s.height };
+            Resolution r = new() { width = s.width, height = s.height };
 #if !UNITY_2022_2_OR_NEWER
             r.refreshRate = s.refreshRate;
 #endif

package/Runtime/Integrations/Reflex/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("WallstopStudios.UnityHelpers.Tests.Editor")]
+[assembly: InternalsVisibleTo("WallstopStudios.UnityHelpers.Tests.Runtime")]
+[assembly: InternalsVisibleTo("WallstopStudios.UnityHelpers.Editor")]
+[assembly: InternalsVisibleTo("WallstopStudios.UnityHelpers.Tests.Runtime.Reflex")]
+[assembly: InternalsVisibleTo("WallstopStudios.UnityHelpers.Tests.Editor.Reflex")]

package/Runtime/Integrations/Reflex/AssemblyInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b0797a503826452bb44815f85f312a1f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Integrations/Reflex/ContainerRelationalExtensions.cs

@@ -0,0 +1,198 @@
+#if REFLEX_PRESENT
+namespace WallstopStudios.UnityHelpers.Integrations.Reflex
+{
+    using System;
+    using System.Collections.Generic;
+    using global::Reflex.Core;
+    using global::Reflex.Injectors;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Core.Attributes;
+    using WallstopStudios.UnityHelpers.Utils;
+
+    /// <summary>
+    /// Extension methods that bridge Reflex containers with relational component assignment.
+    /// </summary>
+    public static class ContainerRelationalExtensions
+    {
+        /// <summary>
+        /// Injects a component using Reflex and assigns its relational fields.
+        /// </summary>
+        /// <typeparam name="T">Component type.</typeparam>
+        /// <param name="container">Reflex container.</param>
+        /// <param name="component">Component instance to inject and hydrate.</param>
+        /// <returns>The injected component instance.</returns>
+        public static T InjectWithRelations<T>(this Container container, T component)
+            where T : Component
+        {
+            if (component == null)
+            {
+                return null;
+            }
+
+            if (container != null)
+            {
+                AttributeInjector.Inject(component, container);
+            }
+
+            container.AssignRelationalComponents(component);
+            return component;
+        }
+
+        /// <summary>
+        /// Assigns relational component fields on the supplied component.
+        /// </summary>
+        /// <param name="container">Reflex container.</param>
+        /// <param name="component">Component to hydrate.</param>
+        public static void AssignRelationalComponents(this Container container, Component component)
+        {
+            if (component == null)
+            {
+                return;
+            }
+
+            IRelationalComponentAssigner assigner = ResolveAssigner(container);
+            if (assigner != null)
+            {
+                assigner.Assign(component);
+                return;
+            }
+
+            component.AssignRelationalComponents();
+        }
+
+        /// <summary>
+        /// Assigns relational component fields across a GameObject hierarchy.
+        /// </summary>
+        /// <param name="container">Reflex container.</param>
+        /// <param name="root">Hierarchy root.</param>
+        /// <param name="includeInactiveChildren">
+        /// When true, includes inactive children during assignment.
+        /// </param>
+        public static void AssignRelationalHierarchy(
+            this Container container,
+            GameObject root,
+            bool includeInactiveChildren = true
+        )
+        {
+            if (root == null)
+            {
+                return;
+            }
+
+            IRelationalComponentAssigner assigner = ResolveAssigner(container);
+            if (assigner != null)
+            {
+                assigner.AssignHierarchy(root, includeInactiveChildren);
+                return;
+            }
+
+            using PooledResource<List<Component>> pooledComponents = Buffers<Component>.List.Get(
+                out List<Component> components
+            );
+            root.GetComponentsInChildren(includeInactiveChildren, components);
+            for (int i = 0; i < components.Count; i++)
+            {
+                Component component = components[i];
+                if (component == null)
+                {
+                    continue;
+                }
+                component.AssignRelationalComponents();
+            }
+        }
+
+        /// <summary>
+        /// Instantiates a component prefab, injects it, and assigns relational fields.
+        /// </summary>
+        /// <typeparam name="T">Component type contained by the prefab.</typeparam>
+        /// <param name="container">Reflex container.</param>
+        /// <param name="prefab">Component prefab.</param>
+        /// <param name="parent">Optional parent transform.</param>
+        /// <returns>The instantiated and hydrated component.</returns>
+        public static T InstantiateComponentWithRelations<T>(
+            this Container container,
+            T prefab,
+            Transform parent = null
+        )
+            where T : Component
+        {
+            if (prefab == null)
+            {
+                throw new ArgumentNullException(nameof(prefab));
+            }
+
+            T instance = UnityEngine.Object.Instantiate(prefab, parent);
+            return container.InjectWithRelations(instance);
+        }
+
+        /// <summary>
+        /// Instantiates a GameObject prefab, injects the hierarchy, and assigns relational fields.
+        /// </summary>
+        /// <param name="container">Reflex container.</param>
+        /// <param name="prefab">GameObject prefab.</param>
+        /// <param name="parent">Optional parent transform.</param>
+        /// <param name="includeInactiveChildren">
+        /// When true, includes inactive children during relational assignment.
+        /// </param>
+        /// <returns>The instantiated GameObject.</returns>
+        public static GameObject InstantiateGameObjectWithRelations(
+            this Container container,
+            GameObject prefab,
+            Transform parent = null,
+            bool includeInactiveChildren = true
+        )
+        {
+            if (prefab == null)
+            {
+                throw new ArgumentNullException(nameof(prefab));
+            }
+
+            GameObject instance = UnityEngine.Object.Instantiate(prefab, parent);
+            container.InjectGameObjectWithRelations(instance, includeInactiveChildren);
+            return instance;
+        }
+
+        /// <summary>
+        /// Injects all components in a hierarchy and assigns relational fields.
+        /// </summary>
+        /// <param name="container">Reflex container.</param>
+        /// <param name="root">Root GameObject.</param>
+        /// <param name="includeInactiveChildren">
+        /// When true, includes inactive children during relational assignment.
+        /// </param>
+        public static void InjectGameObjectWithRelations(
+            this Container container,
+            GameObject root,
+            bool includeInactiveChildren = true
+        )
+        {
+            if (root == null)
+            {
+                return;
+            }
+
+            if (container != null)
+            {
+                GameObjectInjector.InjectRecursive(root, container);
+            }
+
+            container.AssignRelationalHierarchy(root, includeInactiveChildren);
+        }
+
+        private static IRelationalComponentAssigner ResolveAssigner(Container container)
+        {
+            if (container == null)
+            {
+                return null;
+            }
+
+            if (container.HasBinding<IRelationalComponentAssigner>())
+            {
+                return container.Resolve<IRelationalComponentAssigner>();
+            }
+
+            return null;
+        }
+    }
+}
+#endif

package/Runtime/Integrations/Reflex/ContainerRelationalExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9f6bb439e0c448948a916fdea6cecd9f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: