com.wallstop-studios.dxmessaging 2.0.0-rc26.9 → 2.0.0-rc27

package/README.md

@@ -40,16 +40,16 @@ For UntargetedMessages, DxMessaging is significantly faster (roughly 2x) than Un
 ## Windows
 
 | Message Tech | Operations / Second | Allocations? |
-| ------------ | ------------------- | ------------ | 
-| Unity | 2,649,000 | Yes |
-| DxMessaging (GameObject) - Normal | 2,672,800 | No |
-| DxMessaging (Component) - Normal | 2,665,600 | No |
-| DxMessaging (GameObject) - No-Copy | 2,778,800 | No |
-| DxMessaging (Component) - No-Copy | 2,783,800 | No |
-| DxMessaging (Untargeted) - No-Copy | 4,205,600 | No |
-| Reflexive (One Argument) | 2,394,800 | No |
-| Reflexive (Two Arguments) | 1,000,400 | No |
-| Reflexive (Three Arguments) | 993,800 | No |
+| ------------ | ------------------- | ------------ |
+| Unity | 2,496,800 | Yes |
+| DxMessaging (GameObject) - Normal | 2,574,400 | No |
+| DxMessaging (Component) - Normal | 2,539,800 | No |
+| DxMessaging (GameObject) - No-Copy | 2,745,000 | No |
+| DxMessaging (Component) - No-Copy | 2,747,000 | No |
+| DxMessaging (Untargeted) - No-Copy | 4,138,600 | No |
+| Reflexive (One Argument) | 1,954,600 | No |
+| Reflexive (Two Arguments) | 928,800 | No |
+| Reflexive (Three Arguments) | 916,400 | No |
 
 ## Linux
 

package/Runtime/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(
+    assemblyName: "WallstopStudios.DxMessaging.Tests.Runtime",
+    AllInternalsVisible = true
+)]
+[assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Editor")]

package/Runtime/AssemblyInfo.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 83aab80bf265483fb08c5f884e4b24fc
+timeCreated: 1759525804

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -51,7 +51,7 @@ namespace DxMessaging.Core.DataStructure
         public int Count { get; private set; }
 
         private readonly List<T> _buffer;
-        private readonly List<T> _cache = new();
+        private readonly List<T> _cache;
         private int _position;
 
         public T this[int index]
@@ -79,6 +79,7 @@ namespace DxMessaging.Core.DataStructure
             _position = 0;
             Count = 0;
             _buffer = new List<T>();
+            _cache = new List<T>();
             if (initialContents != null)
             {
                 foreach (T item in initialContents)
@@ -158,49 +159,41 @@ namespace DxMessaging.Core.DataStructure
                 return false;
             }
 
-            // Rebuild the buffer with linearized data
-            _buffer.Clear();
-            _buffer.AddRange(_cache);
-            Count = _cache.Count;
-            _position = Count < Capacity ? Count : 0;
+            RebuildFromCache();
             return true;
         }
 
-        public int RemoveAll(Func<T, bool> predicate)
+        public int RemoveAll(Predicate<T> predicate)
         {
             if (Count == 0)
             {
                 return 0;
             }
 
-            int write = 0;
-            int removedCount = 0;
-
+            _cache.Clear();
             for (int i = 0; i < Count; ++i)
             {
-                int readIdx = AdjustedIndexFor(i);
-                T item = _buffer[readIdx];
-                if (predicate(item))
-                {
-                    removedCount++;
-                }
-                else
-                {
-                    _buffer[write++] = item;
-                }
+                _cache.Add(_buffer[AdjustedIndexFor(i)]);
             }
 
+            int removedCount = _cache.RemoveAll(predicate);
             if (removedCount == 0)
             {
                 return 0;
             }
 
-            _buffer.RemoveRange(write, _buffer.Count - write);
-            Count -= removedCount;
-            _position = Count < Capacity ? Count : 0;
+            RebuildFromCache();
             return removedCount;
         }
 
+        private void RebuildFromCache()
+        {
+            _buffer.Clear();
+            _buffer.AddRange(_cache);
+            Count = _cache.Count;
+            _position = Count < Capacity ? Count : 0;
+        }
+
         public void Clear()
         {
             Count = 0;

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -736,8 +736,6 @@ namespace DxMessaging.Core.MessageBus
             }
 
             bool foundAnyHandlers = false;
-            Dictionary<InstanceId, HandlerCache<int, HandlerCache>> targetedHandlers;
-            HandlerCache<int, HandlerCache> sortedHandlers;
 
             if (typeof(TMessage) == typeof(ReflexiveMessage))
             {
@@ -931,8 +929,13 @@ namespace DxMessaging.Core.MessageBus
             }
 
             if (
-                _targetedSinks.TryGetValue<TMessage>(out targetedHandlers)
-                && targetedHandlers.TryGetValue(target, out sortedHandlers)
+                _targetedSinks.TryGetValue<TMessage>(
+                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> targetedHandlers
+                )
+                && targetedHandlers.TryGetValue(
+                    target,
+                    out HandlerCache<int, HandlerCache> sortedHandlers
+                )
                 && 0 < sortedHandlers.handlers.Count
             )
             {
@@ -2415,14 +2418,17 @@ namespace DxMessaging.Core.MessageBus
                 foreach (KeyValuePair<int, List<object>> entry in interceptorStack)
                 {
                     interceptorObjects.Clear();
-                    foreach (object interceptor in entry.Value)
+                    List<object> interceptors = entry.Value;
+                    int count = interceptors.Count;
+
+                    for (int i = 0; i < count; ++i)
                     {
-                        interceptorObjects.Add(interceptor);
+                        interceptorObjects.Add(interceptors[i]);
                     }
 
-                    foreach (object transformer in interceptorObjects)
+                    for (int i = 0; i < interceptorObjects.Count; ++i)
                     {
-                        if (transformer is not UntargetedInterceptor<T> typedTransformer)
+                        if (interceptorObjects[i] is not UntargetedInterceptor<T> typedTransformer)
                         {
                             continue;
                         }
@@ -2460,14 +2466,16 @@ namespace DxMessaging.Core.MessageBus
                 foreach (KeyValuePair<int, List<object>> entry in interceptorStack)
                 {
                     interceptorObjects.Clear();
-                    foreach (object interceptor in entry.Value)
+                    List<object> interceptors = entry.Value;
+                    int count = interceptors.Count;
+                    for (int i = 0; i < count; ++i)
                     {
-                        interceptorObjects.Add(interceptor);
+                        interceptorObjects.Add(interceptors[i]);
                     }
 
-                    foreach (object transformer in interceptorObjects)
+                    for (int i = 0; i < interceptorObjects.Count; ++i)
                     {
-                        if (transformer is not TargetedInterceptor<T> typedTransformer)
+                        if (interceptorObjects[i] is not TargetedInterceptor<T> typedTransformer)
                         {
                             continue;
                         }
@@ -2505,14 +2513,17 @@ namespace DxMessaging.Core.MessageBus
                 foreach (KeyValuePair<int, List<object>> entry in interceptorStack)
                 {
                     interceptorObjects.Clear();
-                    foreach (object interceptor in entry.Value)
+                    List<object> interceptors = entry.Value;
+                    int count = interceptors.Count;
+
+                    for (int i = 0; i < count; ++i)
                     {
-                        interceptorObjects.Add(interceptor);
+                        interceptorObjects.Add(interceptors[i]);
                     }
 
-                    foreach (object transformer in interceptorObjects)
+                    for (int i = 0; i < interceptorObjects.Count; ++i)
                     {
-                        if (transformer is not BroadcastInterceptor<T> typedTransformer)
+                        if (interceptorObjects[i] is not BroadcastInterceptor<T> typedTransformer)
                         {
                             continue;
                         }

package/Runtime/Core/MessageHandler.cs

@@ -1317,8 +1317,19 @@ namespace DxMessaging.Core
 
         private sealed class HandlerActionCache<T>
         {
-            public readonly Dictionary<T, int> handlers = new();
-            public readonly Dictionary<T, T> originalToAugmented = new();
+            internal readonly struct Entry
+            {
+                public Entry(T handler, int count)
+                {
+                    this.handler = handler;
+                    this.count = count;
+                }
+
+                public readonly T handler;
+                public readonly int count;
+            }
+
+            public readonly Dictionary<T, Entry> entries = new();
             public readonly List<T> cache = new();
             public long version;
             public long lastSeenVersion = -1;
@@ -1522,7 +1533,7 @@ namespace DxMessaging.Core
             public void HandleGlobalUntargeted(ref IUntargetedMessage message)
             {
                 RunFastHandlers(_globalUntargetedFastHandlers, ref message);
-                if (_globalUntargetedHandlers?.handlers is not { Count: > 0 })
+                if (_globalUntargetedHandlers?.entries is not { Count: > 0 })
                 {
                     return;
                 }
@@ -1545,7 +1556,7 @@ namespace DxMessaging.Core
             {
                 RunFastHandlers(ref target, _globalTargetedFastHandlers, ref message);
 
-                if (_globalTargetedHandlers?.handlers is not { Count: > 0 })
+                if (_globalTargetedHandlers?.entries is not { Count: > 0 })
                 {
                     return;
                 }
@@ -1568,7 +1579,7 @@ namespace DxMessaging.Core
             {
                 RunFastHandlers(ref source, _globalBroadcastFastHandlers, ref message);
 
-                if (_globalBroadcastHandlers?.handlers is not { Count: > 0 })
+                if (_globalBroadcastHandlers?.entries is not { Count: > 0 })
                 {
                     return;
                 }
@@ -2433,7 +2444,7 @@ namespace DxMessaging.Core
                 where TMessage : IMessage
                 where TU : IMessage
             {
-                if (cache?.handlers is not { Count: > 0 })
+                if (cache?.entries is not { Count: > 0 })
                 {
                     return;
                 }
@@ -2494,7 +2505,7 @@ namespace DxMessaging.Core
                 where TMessage : IMessage
                 where TU : IMessage
             {
-                if (cache?.handlers is not { Count: > 0 })
+                if (cache?.entries is not { Count: > 0 })
                 {
                     return;
                 }
@@ -2789,10 +2800,15 @@ namespace DxMessaging.Core
 
                 List<TU> cache = actionCache.cache;
                 cache.Clear();
-                foreach (TU handler in actionCache.originalToAugmented.Values)
+
+                if (actionCache.entries.Count > 0)
                 {
-                    cache.Add(handler);
+                    foreach (HandlerActionCache<TU>.Entry entry in actionCache.entries.Values)
+                    {
+                        cache.Add(entry.handler);
+                    }
                 }
+
                 actionCache.lastSeenVersion = actionCache.version;
                 return cache;
             }
@@ -2829,63 +2845,78 @@ namespace DxMessaging.Core
                     sortedHandlers[priority] = cache;
                 }
 
-                Dictionary<TU, int> handlers = cache.handlers;
-                int count = handlers.GetValueOrDefault(originalHandler, 0);
-                if (count == 0)
+                if (
+                    !cache.entries.TryGetValue(
+                        originalHandler,
+                        out HandlerActionCache<TU>.Entry entry
+                    )
+                )
                 {
-                    cache.originalToAugmented[originalHandler] = augmentedHandler;
+                    entry = new HandlerActionCache<TU>.Entry(augmentedHandler, 0);
                 }
-                handlers[originalHandler] = count + 1;
+
+                entry =
+                    entry.count == 0
+                        ? new HandlerActionCache<TU>.Entry(augmentedHandler, 1)
+                        : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
+
+                cache.entries[originalHandler] = entry;
+                cache.version++;
 
                 Dictionary<
                     InstanceId,
                     Dictionary<int, HandlerActionCache<TU>>
                 > localHandlersByContext = handlersByContext;
 
-                cache.version++;
                 return () =>
                 {
-                    cache.version++;
                     if (!localHandlersByContext.TryGetValue(context, out sortedHandlers))
                     {
                         return;
                     }
 
-                    if (!sortedHandlers.TryGetValue(priority, out cache))
+                    if (
+                        !sortedHandlers.TryGetValue(priority, out HandlerActionCache<TU> localCache)
+                    )
                     {
                         return;
                     }
 
-                    handlers = cache.handlers;
-
-                    if (!handlers.TryGetValue(originalHandler, out count))
+                    if (
+                        !localCache.entries.TryGetValue(
+                            originalHandler,
+                            out HandlerActionCache<TU>.Entry localEntry
+                        )
+                    )
                     {
                         return;
                     }
 
-                    // Always invoke deregistration action, as MessageBus dedupes this as well
+                    localCache.version++;
+
                     deregistration?.Invoke();
 
-                    if (count <= 1)
+                    if (localEntry.count <= 1)
                     {
-                        _ = handlers.Remove(originalHandler);
-                        _ = cache.originalToAugmented.Remove(originalHandler);
-                        if (0 < handlers.Count)
-                        {
-                            return;
-                        }
-
-                        _ = sortedHandlers.Remove(priority);
-                        if (0 < sortedHandlers.Count)
+                        _ = localCache.entries.Remove(originalHandler);
+                        if (localCache.entries.Count == 0)
                         {
-                            return;
+                            _ = sortedHandlers.Remove(priority);
+                            if (sortedHandlers.Count == 0)
+                            {
+                                localHandlersByContext.Remove(context);
+                            }
                         }
 
-                        localHandlersByContext.Remove(context);
                         return;
                     }
 
-                    handlers[originalHandler] = count - 1;
+                    localEntry = new HandlerActionCache<TU>.Entry(
+                        localEntry.handler,
+                        localEntry.count - 1
+                    );
+
+                    localCache.entries[originalHandler] = localEntry;
                 };
             }
 
@@ -2897,37 +2928,54 @@ namespace DxMessaging.Core
             )
             {
                 cache ??= new HandlerActionCache<TU>();
-                Dictionary<TU, int> handlersByPriority = cache.handlers;
-                int count = handlersByPriority.GetValueOrDefault(originalHandler, 0);
-                if (count == 0)
+
+                if (
+                    !cache.entries.TryGetValue(
+                        originalHandler,
+                        out HandlerActionCache<TU>.Entry entry
+                    )
+                )
                 {
-                    cache.originalToAugmented[originalHandler] = augmentedHandler;
+                    entry = new HandlerActionCache<TU>.Entry(augmentedHandler, 0);
                 }
 
-                handlersByPriority[originalHandler] = count + 1;
+                entry =
+                    entry.count == 0
+                        ? new HandlerActionCache<TU>.Entry(augmentedHandler, 1)
+                        : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
-                Dictionary<TU, int> localHandlers = handlersByPriority;
+                cache.entries[originalHandler] = entry;
+                cache.version++;
 
                 HandlerActionCache<TU> localCache = cache;
-                localCache.version++;
+
                 return () =>
                 {
-                    localCache.version++;
-                    if (!localHandlers.TryGetValue(originalHandler, out count))
+                    if (
+                        !localCache.entries.TryGetValue(
+                            originalHandler,
+                            out HandlerActionCache<TU>.Entry localEntry
+                        )
+                    )
                     {
                         return;
                     }
 
-                    // Always invoke deregistration action, as MessageBus dedupes this as well
+                    localCache.version++;
+
                     deregistration?.Invoke();
-                    if (count <= 1)
+
+                    if (localEntry.count <= 1)
                     {
-                        _ = localHandlers.Remove(originalHandler);
-                        _ = localCache.originalToAugmented.Remove(originalHandler);
+                        _ = localCache.entries.Remove(originalHandler);
                         return;
                     }
 
-                    localHandlers[originalHandler] = count - 1;
+                    localEntry = new HandlerActionCache<TU>.Entry(
+                        localEntry.handler,
+                        localEntry.count - 1
+                    );
+                    localCache.entries[originalHandler] = localEntry;
                 };
             }
 
@@ -2947,44 +2995,64 @@ namespace DxMessaging.Core
                     handlers[priority] = cache;
                 }
 
-                int count = cache.handlers.GetValueOrDefault(originalHandler, 0);
-                if (count == 0)
+                if (
+                    !cache.entries.TryGetValue(
+                        originalHandler,
+                        out HandlerActionCache<TU>.Entry entry
+                    )
+                )
                 {
-                    cache.originalToAugmented[originalHandler] = augmentedHandler;
+                    entry = new HandlerActionCache<TU>.Entry(augmentedHandler, 0);
                 }
 
-                cache.handlers[originalHandler] = count + 1;
+                entry =
+                    entry.count == 0
+                        ? new HandlerActionCache<TU>.Entry(augmentedHandler, 1)
+                        : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
-                Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;
+                cache.entries[originalHandler] = entry;
                 cache.version++;
 
+                Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;
+
                 return () =>
                 {
-                    cache.version++;
-                    if (!localHandlers.TryGetValue(priority, out cache))
+                    if (!localHandlers.TryGetValue(priority, out HandlerActionCache<TU> localCache))
                     {
                         return;
                     }
 
-                    if (!cache.handlers.TryGetValue(originalHandler, out count))
+                    if (
+                        !localCache.entries.TryGetValue(
+                            originalHandler,
+                            out HandlerActionCache<TU>.Entry localEntry
+                        )
+                    )
                     {
                         return;
                     }
 
-                    // Always invoke deregistration action, as MessageBus dedupes this as well
+                    localCache.version++;
+
                     deregistration?.Invoke();
-                    if (count <= 1)
+
+                    if (localEntry.count <= 1)
                     {
-                        _ = cache.handlers.Remove(originalHandler);
-                        _ = cache.originalToAugmented.Remove(originalHandler);
-                        if (cache.handlers.Count == 0)
+                        _ = localCache.entries.Remove(originalHandler);
+                        if (localCache.entries.Count == 0)
                         {
                             _ = localHandlers.Remove(priority);
                         }
+
                         return;
                     }
 
-                    cache.handlers[originalHandler] = count - 1;
+                    localEntry = new HandlerActionCache<TU>.Entry(
+                        localEntry.handler,
+                        localEntry.count - 1
+                    );
+
+                    localCache.entries[originalHandler] = localEntry;
                 };
             }
         }

package/Runtime/Core/MessageRegistrationToken.cs

@@ -1,5 +1,3 @@
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("WallstopStudios.Dxmessaging.Editor")]
-
 namespace DxMessaging.Core
 {
     using System;

package/Runtime/Unity/MessageAwareComponent.cs

@@ -16,6 +16,11 @@ namespace DxMessaging.Unity
         /// </summary>
         protected virtual bool MessageRegistrationTiedToEnableStatus => true;
 
+        /// <summary>
+        ///     If true, will register/unregister handles for StringMessages.
+        /// </summary>
+        protected virtual bool RegisterForStringMessages => true;
+
         protected bool _isQuitting;
 
         protected MessagingComponent _messagingComponent;
@@ -29,17 +34,20 @@ namespace DxMessaging.Unity
 
         protected virtual void RegisterMessageHandlers()
         {
-            _ = _messageRegistrationToken.RegisterGameObjectTargeted<StringMessage>(
-                gameObject,
-                HandleStringGameObjectMessage
-            );
-            _ = _messageRegistrationToken.RegisterComponentTargeted<StringMessage>(
-                this,
-                HandleStringComponentMessage
-            );
-            _ = _messageRegistrationToken.RegisterUntargeted<GlobalStringMessage>(
-                HandleGlobalStringMessage
-            );
+            if (RegisterForStringMessages)
+            {
+                _ = _messageRegistrationToken.RegisterGameObjectTargeted<StringMessage>(
+                    gameObject,
+                    HandleStringGameObjectMessage
+                );
+                _ = _messageRegistrationToken.RegisterComponentTargeted<StringMessage>(
+                    this,
+                    HandleStringComponentMessage
+                );
+                _ = _messageRegistrationToken.RegisterUntargeted<GlobalStringMessage>(
+                    HandleGlobalStringMessage
+                );
+            }
         }
 
         protected virtual void OnEnable()
@@ -52,11 +60,6 @@ namespace DxMessaging.Unity
 
         protected virtual void OnDisable()
         {
-            if (_isQuitting)
-            {
-                return;
-            }
-
             if (MessageRegistrationTiedToEnableStatus)
             {
                 _messageRegistrationToken?.Disable();
@@ -65,11 +68,6 @@ namespace DxMessaging.Unity
 
         protected virtual void OnDestroy()
         {
-            if (_isQuitting)
-            {
-                return;
-            }
-
             _messageRegistrationToken?.Disable();
             _messageRegistrationToken = null;
         }