com.wallstop-studios.unity-helpers 2.1.1 → 2.1.2

package/Runtime/Core/Attributes/RelationalComponentAssigner.cs

@@ -14,6 +14,8 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
     public sealed class RelationalComponentAssigner : IRelationalComponentAssigner
     {
         private readonly AttributeMetadataCache _metadataCache;
+        private readonly Dictionary<Type, bool> _hasAssignmentsCache;
+        private readonly object _cacheLock = new();
 
         /// <summary>
         /// Creates a new assigner using the active <see cref="AttributeMetadataCache.Instance"/>.
@@ -27,6 +29,7 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
         public RelationalComponentAssigner(AttributeMetadataCache metadataCache)
         {
             _metadataCache = metadataCache;
+            _hasAssignmentsCache = new Dictionary<Type, bool>();
         }
 
         /// <inheritdoc />
@@ -37,11 +40,20 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
                 return false;
             }
 
+            lock (_cacheLock)
+            {
+                if (_hasAssignmentsCache.TryGetValue(componentType, out bool cachedResult))
+                {
+                    return cachedResult;
+                }
+            }
+
             AttributeMetadataCache cache = _metadataCache ?? AttributeMetadataCache.Instance;
             if (cache == null)
             {
-                // Fallback to reflection-based discovery when no cache is available
-                return HasRelationalAttributesViaReflection(componentType);
+                bool reflectionResult = HasRelationalAttributesViaReflection(componentType);
+                StoreCacheResult(componentType, reflectionResult);
+                return reflectionResult;
             }
 
             Type current = componentType;
@@ -55,13 +67,24 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
                     && fields.Length > 0
                 )
                 {
+                    StoreCacheResult(componentType, true);
                     return true;
                 }
                 current = current.BaseType;
             }
 
             // Fallback: inspect fields via reflection to detect relational attributes
-            return HasRelationalAttributesViaReflection(componentType);
+            bool result = HasRelationalAttributesViaReflection(componentType);
+            StoreCacheResult(componentType, result);
+            return result;
+        }
+
+        private void StoreCacheResult(Type componentType, bool result)
+        {
+            lock (_cacheLock)
+            {
+                _hasAssignmentsCache[componentType] = result;
+            }
         }
 
         private static bool HasRelationalAttributesViaReflection(Type componentType)

package/Runtime/Core/Attributes/RelationalComponentExtensions.cs

@@ -1,5 +1,6 @@
 namespace WallstopStudios.UnityHelpers.Core.Attributes
 {
+    using System;
     using UnityEngine;
 
     /// <summary>
@@ -53,9 +54,24 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
         /// </example>
         public static void AssignRelationalComponents(this Component component)
         {
-            component.AssignParentComponents();
-            component.AssignSiblingComponents();
-            component.AssignChildComponents();
+            if (component == null)
+            {
+                return;
+            }
+
+            Type componentType = component.GetType();
+            ParentComponentExtensions.AssignParentComponents(
+                component,
+                ParentComponentExtensions.GetOrCreateFields(componentType)
+            );
+            SiblingComponentExtensions.AssignSiblingComponents(
+                component,
+                SiblingComponentExtensions.GetOrCreateFields(componentType)
+            );
+            ChildComponentExtensions.AssignChildComponents(
+                component,
+                ChildComponentExtensions.GetOrCreateFields(componentType)
+            );
         }
     }
 }

package/Runtime/Core/Attributes/SiblingComponentAttribute.cs

@@ -3,6 +3,9 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
     using System;
     using System.Collections;
     using System.Collections.Generic;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Reflection;
     using UnityEngine;
     using WallstopStudios.UnityHelpers.Core.Extension;
     using WallstopStudios.UnityHelpers.Utils;
@@ -86,11 +89,22 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
         /// </example>
         public static void AssignSiblingComponents(this Component component)
         {
-            Type componentType = component.GetType();
             FieldMetadata<SiblingComponentAttribute>[] fields = FieldsByType.GetOrAdd(
-                componentType,
+                component.GetType(),
                 type => GetFieldMetadata<SiblingComponentAttribute>(type)
             );
+            AssignSiblingComponents(component, fields);
+        }
+
+        internal static void AssignSiblingComponents(
+            Component component,
+            FieldMetadata<SiblingComponentAttribute>[] fields
+        )
+        {
+            if (component == null || fields == null || fields.Length == 0)
+            {
+                return;
+            }
 
             foreach (FieldMetadata<SiblingComponentAttribute> metadata in fields)
             {
@@ -107,103 +121,142 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
                 }
                 else
                 {
-                    FilterParameters filters = new(metadata.attribute);
-                    switch (metadata.kind)
+                    FilterParameters filters = metadata.Filters;
+                    if (
+                        !metadata.isInterface
+                        && !filters.RequiresPostProcessing
+                        && metadata.attribute.MaxCount <= 0
+                    )
+                    {
+                        foundSibling = TryAssignSiblingCollectionFast(component, metadata);
+                    }
+                    else
                     {
-                        case FieldKind.Array:
+                        switch (metadata.kind)
                         {
-                            using PooledResource<List<Component>> componentBuffer =
-                                Buffers<Component>.List.Get(out List<Component> components);
-                            GetComponentsOfType(
-                                component,
-                                metadata.elementType,
-                                metadata.isInterface,
-                                metadata.attribute.AllowInterfaces,
-                                components
-                            );
-
-                            int filteredCount = FilterComponentsInPlace(
-                                components,
-                                filters,
-                                metadata.attribute,
-                                metadata.elementType,
-                                metadata.isInterface
-                            );
-
-                            Array correctTypedArray = metadata.arrayCreator(filteredCount);
-                            for (int i = 0; i < filteredCount; ++i)
+                            case FieldKind.Array:
                             {
-                                correctTypedArray.SetValue(components[i], i);
-                            }
+                                using PooledResource<List<Component>> componentBuffer =
+                                    Buffers<Component>.List.Get(out List<Component> components);
+                                GetComponentsOfType(
+                                    component,
+                                    metadata.elementType,
+                                    metadata.isInterface,
+                                    metadata.attribute.AllowInterfaces,
+                                    components
+                                );
 
-                            metadata.setter(component, correctTypedArray);
-                            foundSibling = filteredCount > 0;
-                            break;
-                        }
-                        case FieldKind.List:
-                        {
-                            using PooledResource<List<Component>> componentBuffer =
-                                Buffers<Component>.List.Get(out List<Component> components);
-                            GetComponentsOfType(
-                                component,
-                                metadata.elementType,
-                                metadata.isInterface,
-                                metadata.attribute.AllowInterfaces,
-                                components
-                            );
-
-                            int filteredCount = FilterComponentsInPlace(
-                                components,
-                                filters,
-                                metadata.attribute,
-                                metadata.elementType,
-                                metadata.isInterface
-                            );
-
-                            IList instance = metadata.listCreator(filteredCount);
-                            for (int i = 0; i < filteredCount; ++i)
+                                int filteredCount =
+                                    !filters.RequiresPostProcessing
+                                    && metadata.attribute.MaxCount <= 0
+                                        ? components.Count
+                                        : FilterComponentsInPlace(
+                                            components,
+                                            filters,
+                                            metadata.attribute,
+                                            metadata.elementType,
+                                            metadata.isInterface
+                                        );
+
+                                Array correctTypedArray = metadata.arrayCreator(filteredCount);
+                                for (int i = 0; i < filteredCount; ++i)
+                                {
+                                    correctTypedArray.SetValue(components[i], i);
+                                }
+
+                                metadata.SetValue(component, correctTypedArray);
+                                foundSibling = filteredCount > 0;
+                                break;
+                            }
+                            case FieldKind.List:
                             {
-                                instance.Add(components[i]);
+                                using PooledResource<List<Component>> componentBuffer =
+                                    Buffers<Component>.List.Get(out List<Component> components);
+                                GetComponentsOfType(
+                                    component,
+                                    metadata.elementType,
+                                    metadata.isInterface,
+                                    metadata.attribute.AllowInterfaces,
+                                    components
+                                );
+
+                                int filteredCount =
+                                    !filters.RequiresPostProcessing
+                                    && metadata.attribute.MaxCount <= 0
+                                        ? components.Count
+                                        : FilterComponentsInPlace(
+                                            components,
+                                            filters,
+                                            metadata.attribute,
+                                            metadata.elementType,
+                                            metadata.isInterface
+                                        );
+
+                                object existing = metadata.GetValue(component);
+                                if (existing is IList instance)
+                                {
+                                    instance.Clear();
+                                }
+                                else
+                                {
+                                    instance = metadata.listCreator(filteredCount);
+                                    metadata.SetValue(component, instance);
+                                }
+                                for (int i = 0; i < filteredCount; ++i)
+                                {
+                                    instance.Add(components[i]);
+                                }
+
+                                foundSibling = filteredCount > 0;
+                                break;
                             }
+                            case FieldKind.HashSet:
+                            {
+                                using PooledResource<List<Component>> componentBuffer =
+                                    Buffers<Component>.List.Get(out List<Component> components);
+                                GetComponentsOfType(
+                                    component,
+                                    metadata.elementType,
+                                    metadata.isInterface,
+                                    metadata.attribute.AllowInterfaces,
+                                    components
+                                );
 
-                            metadata.setter(component, instance);
-                            foundSibling = filteredCount > 0;
-                            break;
-                        }
-                        case FieldKind.HashSet:
-                        {
-                            using PooledResource<List<Component>> componentBuffer =
-                                Buffers<Component>.List.Get(out List<Component> components);
-                            GetComponentsOfType(
-                                component,
-                                metadata.elementType,
-                                metadata.isInterface,
-                                metadata.attribute.AllowInterfaces,
-                                components
-                            );
-
-                            int filteredCount = FilterComponentsInPlace(
-                                components,
-                                filters,
-                                metadata.attribute,
-                                metadata.elementType,
-                                metadata.isInterface
-                            );
-
-                            object instance = metadata.hashSetCreator(filteredCount);
-                            for (int i = 0; i < filteredCount; ++i)
+                                int filteredCount =
+                                    !filters.RequiresPostProcessing
+                                    && metadata.attribute.MaxCount <= 0
+                                        ? components.Count
+                                        : FilterComponentsInPlace(
+                                            components,
+                                            filters,
+                                            metadata.attribute,
+                                            metadata.elementType,
+                                            metadata.isInterface
+                                        );
+
+                                object instance = metadata.GetValue(component);
+                                if (instance != null && metadata.hashSetClearer != null)
+                                {
+                                    metadata.hashSetClearer(instance);
+                                }
+                                else
+                                {
+                                    instance = metadata.hashSetCreator(filteredCount);
+                                    metadata.SetValue(component, instance);
+                                }
+                                for (int i = 0; i < filteredCount; ++i)
+                                {
+                                    metadata.hashSetAdder(instance, components[i]);
+                                }
+
+                                foundSibling = filteredCount > 0;
+                                break;
+                            }
+                            default:
                             {
-                                metadata.hashSetAdder(instance, components[i]);
+                                foundSibling = TryAssignSingleSibling(component, metadata);
+                                break;
                             }
-
-                            metadata.setter(component, instance);
-                            foundSibling = filteredCount > 0;
-                            break;
-                        }
-                        default:
-                        {
-                            foundSibling = TryAssignSingleSibling(component, metadata);
-                            break;
                         }
                     }
                 }
@@ -215,6 +268,11 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
             }
         }
 
+        internal static FieldMetadata<SiblingComponentAttribute>[] GetOrCreateFields(Type type)
+        {
+            return FieldsByType.GetOrAdd(type, t => GetFieldMetadata<SiblingComponentAttribute>(t));
+        }
+
         private static bool TryAssignSingleSibling(
             Component component,
             FieldMetadata<SiblingComponentAttribute> metadata
@@ -236,7 +294,7 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
             {
                 if (component.TryGetComponent(metadata.elementType, out Component sibling))
                 {
-                    metadata.setter(component, sibling);
+                    metadata.SetValue(component, sibling);
                     return true;
                 }
                 return false;
@@ -255,10 +313,125 @@ namespace WallstopStudios.UnityHelpers.Core.Attributes
                 )
             )
             {
-                metadata.setter(component, resolved);
+                metadata.SetValue(component, resolved);
                 return true;
             }
             return false;
         }
+
+        private static bool TryAssignSiblingCollectionFast(
+            Component component,
+            FieldMetadata<SiblingComponentAttribute> metadata
+        )
+        {
+            Array componentsArray = SiblingComponentFastInvoker.GetArray(
+                component,
+                metadata.elementType
+            );
+
+            return AssignComponentsFromArray(component, metadata, componentsArray);
+        }
+
+        private static bool AssignComponentsFromArray(
+            Component component,
+            FieldMetadata<SiblingComponentAttribute> metadata,
+            Array componentsArray
+        )
+        {
+            if (componentsArray == null)
+            {
+                componentsArray = Array.CreateInstance(metadata.elementType, 0);
+            }
+
+            int count = componentsArray.Length;
+
+            switch (metadata.kind)
+            {
+                case FieldKind.Array:
+                {
+                    metadata.SetValue(component, componentsArray);
+                    return count > 0;
+                }
+                case FieldKind.List:
+                {
+                    if (metadata.GetValue(component) is IList instance)
+                    {
+                        instance.Clear();
+                    }
+                    else
+                    {
+                        instance = metadata.listCreator(count);
+                        metadata.SetValue(component, instance);
+                    }
+
+                    for (int i = 0; i < count; ++i)
+                    {
+                        instance.Add(componentsArray.GetValue(i));
+                    }
+
+                    return count > 0;
+                }
+                case FieldKind.HashSet:
+                {
+                    object hashSet = metadata.GetValue(component);
+                    if (hashSet != null && metadata.hashSetClearer != null)
+                    {
+                        metadata.hashSetClearer(hashSet);
+                    }
+                    else
+                    {
+                        hashSet = metadata.hashSetCreator(count);
+                        metadata.SetValue(component, hashSet);
+                    }
+
+                    for (int i = 0; i < count; ++i)
+                    {
+                        metadata.hashSetAdder(hashSet, componentsArray.GetValue(i));
+                    }
+
+                    return count > 0;
+                }
+                default:
+                {
+                    return TryAssignSingleSibling(component, metadata);
+                }
+            }
+        }
+    }
+
+    internal static class SiblingComponentFastInvoker
+    {
+        private static readonly Dictionary<Type, Func<Component, Array>> ArrayGetters = new();
+
+        private static readonly MethodInfo GetComponentsGenericDefinition = typeof(Component)
+            .GetMethods(BindingFlags.Instance | BindingFlags.Public)
+            .First(method =>
+                method.Name == nameof(Component.GetComponents)
+                && method.IsGenericMethodDefinition
+                && method.GetParameters().Length == 0
+            );
+
+        internal static Array GetArray(Component component, Type elementType)
+        {
+            if (!ArrayGetters.TryGetValue(elementType, out Func<Component, Array> getter))
+            {
+                getter = CreateArrayGetter(elementType);
+                ArrayGetters[elementType] = getter;
+            }
+
+            return getter(component);
+        }
+
+        private static Func<Component, Array> CreateArrayGetter(Type elementType)
+        {
+            MethodInfo closedMethod = GetComponentsGenericDefinition.MakeGenericMethod(elementType);
+            ParameterExpression componentParameter = Expression.Parameter(
+                typeof(Component),
+                "component"
+            );
+            MethodCallExpression invoke = Expression.Call(componentParameter, closedMethod);
+            UnaryExpression convert = Expression.Convert(invoke, typeof(Array));
+            return Expression.Lambda<Func<Component, Array>>(convert, componentParameter).Compile();
+        }
     }
 }

package/Runtime/Core/CodeGen.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 364c9d10ad9c44edae26897ee1a02506
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/ImmutableBitSet.cs

@@ -5,6 +5,7 @@ namespace WallstopStudios.UnityHelpers.Core.DataStructure
     using System.Collections.Generic;
     using System.Runtime.CompilerServices;
     using ProtoBuf;
+    using WallstopStudios.UnityHelpers.Core.Helper;
 
     /// <summary>
     /// An immutable value-type variant of BitSet that provides read-only access to bit data.
@@ -318,14 +319,8 @@ namespace WallstopStudios.UnityHelpers.Core.DataStructure
             {
                 return false;
             }
-            for (int i = 0; i < _bits.Length; i++)
-            {
-                if (_bits[i] != other._bits[i])
-                {
-                    return false;
-                }
-            }
-            return true;
+
+            return _bits.AsSpan().SequenceEqual(other._bits);
         }
 
         public override bool Equals(object obj)
@@ -335,18 +330,8 @@ namespace WallstopStudios.UnityHelpers.Core.DataStructure
 
         public override int GetHashCode()
         {
-            unchecked
-            {
-                int hash = _capacity.GetHashCode();
-                if (_bits != null)
-                {
-                    foreach (ulong bit in _bits)
-                    {
-                        hash = (hash * 397) ^ bit.GetHashCode();
-                    }
-                }
-                return hash;
-            }
+            int hash = Objects.SpanHashCode<ulong>(_bits.AsSpan());
+            return Objects.HashCode(_capacity, hash);
         }
 
         public static bool operator ==(ImmutableBitSet left, ImmutableBitSet right)

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

@@ -406,13 +406,17 @@ namespace WallstopStudios.UnityHelpers.Core.Helper.Logging
                 RemoveDecorationInternal(existing.priority, existing.index);
             }
 
-            List<(
-                string tag,
-                bool editorOnly,
-                Func<string, bool> predicate,
-                Func<string, object, string> formatter
-            )> matchingDecorations;
-            if (!_matchingDecorations.TryGetValue(priority, out matchingDecorations))
+            if (
+                !_matchingDecorations.TryGetValue(
+                    priority,
+                    out List<(
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    )> matchingDecorations
+                )
+            )
             {
                 matchingDecorations = new List<(
                     string tag,

package/Runtime/Core/Helper/Objects.cs

@@ -58,7 +58,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
         /// <summary>
         /// Combines hash codes for a span of values into a deterministic composite hash.
         /// </summary>
-        public static int HashCode<T>(ReadOnlySpan<T> values)
+        public static int SpanHashCode<T>(ReadOnlySpan<T> values)
         {
             if (values.IsEmpty)
             {