com.wallstop-studios.dxmessaging 2.0.0-rc20 → 2.0.0-rc22

package/.github/workflows/npm-publish.yml

@@ -29,7 +29,16 @@ jobs:
         run: |
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
             echo "Manual trigger detected. Skipping version check."
+            NEW_VERSION=$(jq -r '.version' package.json)
+            echo "NEW_VERSION=$NEW_VERSION" >> $GITHUB_ENV
             echo "should_publish=true" >> $GITHUB_ENV
+            if [[ "$NEW_VERSION" == *"rc"* ]]; then
+              echo "This is a pre-release (next tag)."
+              echo "NPM_TAG=next" >> $GITHUB_ENV
+            else
+              echo "This is a stable release (latest tag)."
+              echo "NPM_TAG=latest" >> $GITHUB_ENV
+            fi
           else
             PREV_VERSION=$(git show HEAD~1:package.json | jq -r '.version' || echo "0.0.0")
             NEW_VERSION=$(jq -r '.version' package.json)

package/Editor/Analyzers/System.Collections.Immutable.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 390bb9381fa79fd458906a865ace0e80
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/SetupCscRsp.cs

@@ -36,6 +36,7 @@ namespace DxMessaging.Editor
             "Microsoft.CodeAnalysis.CSharp.dll",
             "System.Reflection.Metadata.dll",
             "System.Runtime.CompilerServices.Unsafe.dll",
+            "System.Collections.Immutable.dll",
         };
 
         private static readonly string LibraryArgument = $"-a:\"{LibraryPathRelative}\"";

package/README.md

@@ -33,16 +33,18 @@ Check out the latest [Releases](https://github.com/wallstop/DxMessaging/releases
 Grab a copy of this repo (either `git clone` both [this repo](https://github.com/wallstop/DxMessaging) *and* [Unity Helpers](https://github.com/wallstop/unity-helpers) or [download a zip of the source](https://github.com/wallstop/DxMessaging/archive/refs/heads/master.zip) and [Unity Helper's source](https://github.com/wallstop/unity-helpers/archive/refs/heads/main.zip)) and copy the contents to your project's `Assets` folder.
 
 # Benchmarks
-DxMessaging is currently roughly on-par with than Unity's built in messaging solution (when running in Unity). [Source](./Tests/Runtime/Benchmarks/PerformanceTests.cs). However, it is allocation-free and can be used in hot paths.
+In addition to providing a richer feature set, DxMessaging is *faster* than Unity's built in messaging solution. [Source](./Tests/Runtime/Benchmarks/PerformanceTests.cs). It is allocation-free and can be used in hot paths. 
+
+For UntargetedMessages, DxMessaging is significantly faster (roughly 2x) than Unity.
 
 | Message Tech | Operations / Second | Allocations? |
 | ------------ | ------------------- | ------------ | 
-| Unity | 2,621,200 | Yes |
-| DxMessaging (GameObject) - Normal | 2,048,600 | No |
-| DxMessaging (Component) - Normal | 2,054,600 | No |
-| DxMessaging (GameObject) - No-Copy | 2,137,800 | No |
-| DxMessaging (Component) - No-Copy | 2,136,400 | No |
-| DxMessaging (Untargeted) - No-Copy | 3,028,400 | No |
+| Unity | 2,566,400 | Yes |
+| DxMessaging (GameObject) - Normal | 2,726,400 | No |
+| DxMessaging (Component) - Normal | 2,749,000 | No |
+| DxMessaging (GameObject) - No-Copy | 2,883,800 | No |
+| DxMessaging (Component) - No-Copy | 2,855,200 | No |
+| DxMessaging (Untargeted) - No-Copy | 4,499,000 | No |
 
 # Functionality
 While not as fast, DxMessaging offers *additional functionality* as compared to Unity's messaging solution.

package/Runtime/Core/Helper/DxMessagingRuntime.cs

@@ -0,0 +1,201 @@
+namespace DxMessaging.Core.Helper
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using Core;
+    using Messages;
+#if UNITY_2017_1_OR_NEWER
+    using UnityEngine;
+#endif
+    public static class DxMessagingRuntime
+    {
+        public static int TotalMessageTypes { get; private set; }
+
+        public static bool Initialized
+        {
+            get
+            {
+                lock (InitializationLock)
+                {
+                    return _isInitialized;
+                }
+            }
+        }
+
+        private static bool _isInitialized;
+        private static readonly object InitializationLock = new();
+
+        static DxMessagingRuntime()
+        {
+            Initialize();
+        }
+
+#if UNITY_2017_1_OR_NEWER
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+#endif
+        public static void Initialize()
+        {
+            lock (InitializationLock)
+            {
+                if (_isInitialized)
+                {
+                    return;
+                }
+
+                Log(() => "DxMessagingRuntime Initializing...", isError: false);
+
+                HashSet<Type> uniqueTypes = new();
+                List<Type> messageTypes = new();
+                Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+                foreach (Assembly assembly in assemblies)
+                {
+                    Type[] types;
+                    try
+                    {
+                        types = assembly.GetTypes();
+                    }
+                    catch (ReflectionTypeLoadException ex)
+                    {
+                        types = ex.Types;
+                    }
+                    catch
+                    {
+                        continue;
+                    }
+
+                    foreach (Type type in types)
+                    {
+                        try
+                        {
+                            if (type == null)
+                            {
+                                continue;
+                            }
+
+                            if (!typeof(IMessage).IsAssignableFrom(type))
+                            {
+                                continue;
+                            }
+
+                            if (type.IsGenericTypeDefinition)
+                            {
+                                continue;
+                            }
+
+                            if (uniqueTypes.Add(type))
+                            {
+                                messageTypes.Add(type);
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            Log(
+                                () =>
+                                    $"Error checking if {type?.FullName} is assignable from IMessage: {e}",
+                                isError: true
+                            );
+                        }
+                    }
+                }
+
+                if (uniqueTypes.Add(typeof(IMessage)))
+                {
+                    messageTypes.Add(typeof(IMessage));
+                }
+                if (uniqueTypes.Add(typeof(ITargetedMessage)))
+                {
+                    messageTypes.Add(typeof(ITargetedMessage));
+                }
+                if (uniqueTypes.Add(typeof(IBroadcastMessage)))
+                {
+                    messageTypes.Add(typeof(IBroadcastMessage));
+                }
+                if (uniqueTypes.Add(typeof(IUntargetedMessage)))
+                {
+                    messageTypes.Add(typeof(IUntargetedMessage));
+                }
+
+                messageTypes.Sort(
+                    (a, b) =>
+                        string.Compare(a.FullName, b.FullName, StringComparison.OrdinalIgnoreCase)
+                );
+
+                TotalMessageTypes = messageTypes.Count;
+                Type helperIndexerGenericDef = typeof(MessageHelperIndexer<>);
+
+                for (int i = 0; i < TotalMessageTypes; ++i)
+                {
+                    Type messageType = messageTypes[i];
+                    try
+                    {
+                        Type specificHelperType = helperIndexerGenericDef.MakeGenericType(
+                            messageType
+                        );
+
+                        FieldInfo idField = specificHelperType.GetField(
+                            "SequentialId",
+                            BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic
+                        );
+                        if (idField != null)
+                        {
+                            idField.SetValue(null, i);
+                        }
+                        else
+                        {
+                            Log(
+                                () =>
+                                    $"Error: Could not find field for SequentialId on MessageHelperIndexer<{messageType.FullName}>.",
+                                isError: true
+                            );
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Log(
+                            () => $"Error setting SequentialId for {messageType.FullName}: {ex}",
+                            isError: true
+                        );
+                    }
+                }
+
+                _isInitialized = true;
+                Log(
+                    () =>
+                        $"DxMessagingRuntime Initialized. Found {TotalMessageTypes} message types.",
+                    isError: false
+                );
+            }
+        }
+
+        private static void Log(Func<string> messageProducer, bool isError)
+        {
+            try
+            {
+                string message = messageProducer();
+#if UNITY_2017_1_OR_NEWER
+                if (isError)
+                {
+                    Debug.LogError(message);
+                }
+                else
+                {
+                    Debug.Log(message);
+                }
+#else
+                Console.WriteLine(message);
+#endif
+            }
+            catch (Exception e)
+            {
+                string errorMessage = $"Error logging message: {e}";
+#if UNITY_2017_1_OR_NEWER
+                Debug.LogError(errorMessage);
+#else
+                Console.WriteLine(errorMessage);
+#endif
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/DxMessagingRuntime.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 84077988aa394abb9c9608cb46690a75
+timeCreated: 1745099950

package/Runtime/Core/Helper/MessageCache.cs

@@ -0,0 +1,105 @@
+namespace DxMessaging.Core.Helper
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public sealed class MessageCache<TValue> : IEnumerable<TValue>
+        where TValue : class, new()
+    {
+        public struct MessageCacheEnumerator : IEnumerator<TValue>
+        {
+            private readonly MessageCache<TValue> _cache;
+
+            private int _index;
+            private TValue _current;
+
+            internal MessageCacheEnumerator(MessageCache<TValue> cache)
+            {
+                _cache = cache;
+                _index = -1;
+                _current = default;
+            }
+
+            public bool MoveNext()
+            {
+                while (++_index < _cache._values.Length)
+                {
+                    _current = _cache._values[_index];
+                    if (_current != null)
+                    {
+                        return true;
+                    }
+                }
+
+                _current = default;
+                return false;
+            }
+
+            public TValue Current => _current;
+
+            object IEnumerator.Current => Current;
+
+            public void Reset()
+            {
+                _index = -1;
+                _current = default;
+            }
+
+            public void Dispose() { }
+        }
+
+        private readonly TValue[] _values = new TValue[DxMessagingRuntime.TotalMessageTypes];
+
+        public TValue GetOrAdd<TMessage>()
+            where TMessage : IMessage
+        {
+            int index = MessageHelperIndexer<TMessage>.SequentialId;
+            TValue value = _values[index];
+            if (value != null)
+            {
+                return value;
+            }
+
+            value = new TValue();
+            _values[index] = value;
+            return value;
+        }
+
+        public void Set<TMessage>(TValue value)
+            where TMessage : IMessage
+        {
+            int index = MessageHelperIndexer<TMessage>.SequentialId;
+            _values[index] = value;
+        }
+
+        public bool TryGetValue<TMessage>(out TValue value)
+            where TMessage : IMessage
+        {
+            int index = MessageHelperIndexer<TMessage>.SequentialId;
+            value = _values[index];
+            return value != null;
+        }
+
+        public void Remove<TMessage>()
+            where TMessage : IMessage
+        {
+            int index = MessageHelperIndexer<TMessage>.SequentialId;
+            _values[index] = null;
+        }
+
+        public MessageCacheEnumerator GetEnumerator()
+        {
+            return new MessageCacheEnumerator(this);
+        }
+
+        IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

package/Runtime/Core/Helper/MessageCache.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23cb3bf7f25d479c862736482ee96fa7
+timeCreated: 1745102344

package/Runtime/Core/Helper/MessageHelperIndexer.cs

@@ -0,0 +1,9 @@
+namespace DxMessaging.Core.Helper
+{
+    public static class MessageHelperIndexer<TMessage>
+        where TMessage : IMessage
+    {
+        // ReSharper disable once StaticMemberInGenericType
+        internal static int SequentialId = -1;
+    }
+}

package/Runtime/Core/Helper/MessageHelperIndexer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 612c352c3d984a3486ac4b19bb69fa37
+timeCreated: 1745101032

package/Runtime/Core/Helper.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 351ee8f890884099b6c7c32e66f196a9
+timeCreated: 1745100990

package/Runtime/Core/IMessage.cs

@@ -8,18 +8,5 @@
     public interface IMessage
     {
         Type MessageType => GetType();
-
-        /// <summary>
-        /// Gets the optimized, unique integer ID for this message type, if available.
-        /// Returns null if this type uses the fallback mechanism (e.g., due to a compile-time
-        /// hash collision or manual implementation without an assigned ID).
-        /// </summary>
-        /// <remarks>
-        /// The ID is generated at compile-time for attributed types and is stable
-        /// across builds assuming the type's fully qualified name does not change.
-        /// It facilitates faster dictionary lookups compared to using System.Type directly.
-        /// Check for HasValue before using the Value.
-        /// </remarks>
-        int? OptimizedMessageId => null;
     }
 }

package/Runtime/Core/MessageBus/IMessageBus.cs

@@ -9,6 +9,9 @@
     /// </summary>
     public interface IMessageBus
     {
+        public static int GlobalSequentialIndex = -1;
+
+        public int RegisteredGlobalSequentialIndex { get; }
         public int RegisteredBroadcast { get; }
 
         public int RegisteredTargeted { get; }
@@ -25,7 +28,7 @@
             where TMessage : IUntargetedMessage;
 
         /// <summary>
-        /// Given an Targeted message and its target, determines whether or not it should be processed or skipped.
+        /// Given a Targeted message and its target, determines whether or not it should be processed or skipped.
         /// </summary>
         /// <typeparam name="TMessage">Specific type of message.</typeparam>
         /// <param name="target">Target of the message.</param>
@@ -38,7 +41,7 @@
             where TMessage : ITargetedMessage;
 
         /// <summary>
-        /// Given an Broadcast message and its source, determines whether or not it should be processed or skipped.
+        /// Given a Broadcast message and its source, determines whether or not it should be processed or skipped.
         /// </summary>
         /// <typeparam name="TMessage">Specific type of message.</typeparam>
         /// <param name="source">Source of the message.</param>