com.wallstop-studios.dxmessaging 2.0.0-rc21 → 2.0.0-rc23

package/Runtime/Core/MessageHandler.cs

@@ -2,8 +2,8 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.Linq;
     using System.Runtime.CompilerServices;
+    using Helper;
     using MessageBus;
     using Messages;
 
@@ -18,6 +18,7 @@
     {
         public delegate void FastHandler<TMessage>(ref TMessage message)
             where TMessage : IMessage;
+
         public delegate void FastHandlerWithContext<TMessage>(
             ref InstanceId context,
             ref TMessage message
@@ -29,17 +30,6 @@
         /// </summary>
         public static readonly MessageBus.MessageBus MessageBus = new();
 
-        /// <summary>
-        /// Maps Types to the corresponding Handler of that type.
-        /// </summary>
-        /// <note>
-        /// Ideally, this would be something like a Dictionary[T, Handler[T]], but that can't be done with C#s type system.
-        /// </note>
-        private readonly Dictionary<
-            IMessageBus,
-            Dictionary<Type, object>
-        > _handlersByTypeByMessageBus;
-
         /// <summary>
         /// Whether this MessageHandler will process messages.
         /// </summary>
@@ -50,10 +40,26 @@
         /// </summary>
         public readonly InstanceId owner;
 
+        /// <summary>
+        /// Maps Types to the corresponding Handler of that type.
+        /// </summary>
+        /// <note>
+        /// Ideally, this would be something like a Dictionary[T, Handler[T]], but that can't be done with C#s type system.
+        /// </note>
+        private readonly List<MessageCache<object>> _handlersByTypeByMessageBus;
+
+        static MessageHandler()
+        {
+            if (!DxMessagingRuntime.Initialized)
+            {
+                DxMessagingRuntime.Initialize();
+            }
+        }
+
         public MessageHandler(InstanceId owner)
         {
             this.owner = owner;
-            _handlersByTypeByMessageBus = new Dictionary<IMessageBus, Dictionary<Type, object>>();
+            _handlersByTypeByMessageBus = new List<MessageCache<object>>();
         }
 
         /// <summary>
@@ -77,13 +83,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleUntargeted(ref message, priority);
             }
@@ -110,13 +110,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleUntargetedPostProcessing(ref message, priority);
             }
@@ -145,13 +139,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleTargeted(ref target, ref message, priority);
             }
@@ -180,13 +168,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleTargetedWithoutTargeting(ref target, ref message, priority);
             }
@@ -215,13 +197,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleTargetedPostProcessing(ref target, ref message, priority);
             }
@@ -250,13 +226,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleTargetedWithoutTargetingPostProcessing(
                     ref target,
@@ -289,13 +259,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleSourcedBroadcast(ref source, ref message, priority);
             }
@@ -324,13 +288,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleSourcedBroadcastWithoutSource(ref source, ref message, priority);
             }
@@ -359,13 +317,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleSourcedBroadcastPostProcessing(ref source, ref message, priority);
             }
@@ -394,13 +346,7 @@
                 return;
             }
 
-            if (
-                GetHandlerForType(
-                    message.MessageType,
-                    messageBus,
-                    out TypedHandler<TMessage> handler
-                )
-            )
+            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
             {
                 handler.HandleBroadcastWithoutSourcePostProcessing(
                     ref source,
@@ -426,7 +372,7 @@
             }
 
             // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
-            if (GetHandlerForType(typeof(IMessage), messageBus, out TypedHandler<IMessage> handler))
+            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 handler.HandleGlobalUntargeted(ref message);
             }
@@ -450,7 +396,7 @@
             }
 
             // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
-            if (GetHandlerForType(typeof(IMessage), messageBus, out TypedHandler<IMessage> handler))
+            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 handler.HandleGlobalTargeted(ref target, ref message);
             }
@@ -474,7 +420,7 @@
             }
 
             // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
-            if (GetHandlerForType(typeof(IMessage), messageBus, out TypedHandler<IMessage> handler))
+            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 handler.HandleGlobalBroadcast(ref source, ref message);
             }
@@ -1265,18 +1211,7 @@
 
         public override string ToString()
         {
-            return new
-            {
-                OwnerId = owner,
-                HandlerTypes = string.Join(
-                    ",",
-                    _handlersByTypeByMessageBus
-                        .Values.SelectMany(handlers => handlers.Keys)
-                        .Distinct()
-                        .Select(type => type.Name)
-                        .OrderBy(x => x)
-                ),
-            }.ToString();
+            return new { OwnerId = owner }.ToString();
         }
 
         /// <summary>
@@ -1287,48 +1222,45 @@
         private TypedHandler<T> GetOrCreateHandlerForType<T>(IMessageBus messageBus)
             where T : IMessage
         {
-            Type type = typeof(T);
-
-            if (
-                !_handlersByTypeByMessageBus.TryGetValue(
-                    messageBus,
-                    out Dictionary<Type, object> handlersByType
-                )
-            )
+            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
+            while (_handlersByTypeByMessageBus.Count <= messageBusIndex)
             {
-                handlersByType = new Dictionary<Type, object>();
-                _handlersByTypeByMessageBus[messageBus] = handlersByType;
+                _handlersByTypeByMessageBus.Add(new MessageCache<object>());
             }
 
-            if (handlersByType.TryGetValue(type, out object existingTypedHandler))
+            MessageCache<object> handlersByType = _handlersByTypeByMessageBus[messageBusIndex];
+            if (handlersByType.TryGetValue<T>(out object untypedHandler))
             {
-                return (TypedHandler<T>)existingTypedHandler;
+                return (TypedHandler<T>)untypedHandler;
             }
 
-            TypedHandler<T> newTypedHandler = new();
-            handlersByType[type] = newTypedHandler;
-            return newTypedHandler;
+            TypedHandler<T> typedHandler = new();
+            handlersByType.Set<T>(typedHandler);
+            return typedHandler;
         }
 
         /// <summary>
         /// Gets an existing Handler for the specific type if it exists.
         /// </summary>
-        /// <param name="type">Message type to get the handler for.</param>
         /// <param name="messageBus">The specific MessageBus to use.</param>
         /// <param name="existingTypedHandler">Existing typed message handler, if one exists.</param>
         /// <returns>Existing handler for the specific type, or null if none exists.</returns>
         private bool GetHandlerForType<T>(
-            Type type,
             IMessageBus messageBus,
             out TypedHandler<T> existingTypedHandler
         )
             where T : IMessage
         {
+            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
+            if (_handlersByTypeByMessageBus.Count <= messageBusIndex)
+            {
+                existingTypedHandler = default;
+                return false;
+            }
+
             if (
-                _handlersByTypeByMessageBus.TryGetValue(
-                    messageBus,
-                    out Dictionary<Type, object> handlersByType
-                ) && handlersByType.TryGetValue(type, out object untypedHandler)
+                _handlersByTypeByMessageBus[messageBusIndex]
+                    .TryGetValue<T>(out object untypedHandler)
             )
             {
                 existingTypedHandler = (TypedHandler<T>)untypedHandler;

package/Runtime/Core/Messages/DxReflexiveMessage.cs

@@ -0,0 +1,132 @@
+namespace DxMessaging.Core.Messages
+{
+    using System;
+    using Attributes;
+
+    [Flags]
+    public enum ReflexiveSendMode
+    {
+        [Obsolete("Please use a valid Send Mode")]
+        None = 0,
+        Flat = 1 << 0,
+        Downwards = 1 << 1,
+        Upwards = 1 << 2,
+    }
+
+    public readonly struct MethodSignatureKey : IEquatable<MethodSignatureKey>
+    {
+        private const int HashBase = 5556137;
+        private const int HashMultiplier = 95785853;
+
+        private readonly string _methodName;
+        private readonly Type[] _parameterTypes;
+
+        private readonly int _hashCode;
+
+        public MethodSignatureKey(string methodName, Type[] parameterTypes)
+            : this()
+        {
+            _methodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
+            _parameterTypes = parameterTypes;
+            _hashCode = CalculateHashCode();
+        }
+
+        private int CalculateHashCode()
+        {
+            int hashCode = HashBase + _methodName.GetHashCode();
+            foreach (Type type in _parameterTypes)
+            {
+                hashCode = hashCode * HashMultiplier + type.GetHashCode();
+            }
+
+            return hashCode;
+        }
+
+        public override int GetHashCode()
+        {
+            return _hashCode;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is MethodSignatureKey other && Equals(other);
+        }
+
+        public bool Equals(MethodSignatureKey other)
+        {
+            if (
+                _parameterTypes.Length != other._parameterTypes.Length
+                || _methodName != other._methodName
+            )
+            {
+                return false;
+            }
+
+            // ReSharper disable once LoopCanBeConvertedToQuery
+            for (int i = 0; i < _parameterTypes.Length; ++i)
+            {
+                if (_parameterTypes[i] != other._parameterTypes[i])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool operator ==(MethodSignatureKey left, MethodSignatureKey right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(MethodSignatureKey left, MethodSignatureKey right)
+        {
+            return !(left == right);
+        }
+    }
+
+    [DxTargetedMessage]
+    public readonly partial struct DxReflexiveMessage
+    {
+        public readonly string method;
+        public readonly ReflexiveSendMode sendMode;
+        public readonly object[] parameters;
+
+        public readonly Type[] parameterTypes;
+
+        public readonly MethodSignatureKey signatureKey;
+
+        public DxReflexiveMessage(
+            string method,
+            ReflexiveSendMode sendMode,
+            params object[] parameters
+        )
+        {
+            this.method = method;
+            this.sendMode = sendMode;
+            this.parameters = parameters;
+
+            if (0 < parameters.Length)
+            {
+                int parameterCount = parameters.Length;
+                parameterTypes = new Type[parameterCount];
+                for (int i = 0; i < parameterCount; i++)
+                {
+                    object parameter = parameters[i];
+                    if (parameter == null)
+                    {
+                        throw new ArgumentNullException(
+                            $"Parameter at index {i} is null, cannot resolve type!"
+                        );
+                    }
+                    parameterTypes[i] = parameter.GetType();
+                }
+            }
+            else
+            {
+                parameterTypes = Array.Empty<Type>();
+            }
+            signatureKey = new MethodSignatureKey(method, parameterTypes);
+        }
+    }
+}

package/Runtime/Core/Messages/DxReflexiveMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9a83f6bf3c0487f9e5cff498dbb6932
+timeCreated: 1745161955

package/Runtime/Core/MessagingDebug.cs

@@ -46,7 +46,7 @@
         /// </note>
         /// <param name="logLevel">Severity of the message.</param>
         /// <param name="message">Format string.</param>
-        /// <param name="args">Args to populate format string with.</param>
+        /// <param name="args">Args to populate the format string with.</param>
         public static void Log(LogLevel logLevel, string message, params object[] args)
         {
             if (!enabled)

package/Runtime/Unity/MessageAwareComponent.cs

@@ -1,39 +1,45 @@
 namespace DxMessaging.Unity
 {
     using Core;
+    using Messages;
     using UnityEngine;
 
     [RequireComponent(typeof(MessagingComponent))]
     public abstract class MessageAwareComponent : MonoBehaviour
     {
+        public virtual MessageRegistrationToken Token => _messageRegistrationToken;
+
         protected MessageRegistrationToken _messageRegistrationToken;
 
         /// <summary>
-        ///     If true, will register/un-register handles when the component is enabled or disabled.
+        ///     If true, will register/unregister handles when the component is enabled or disabled.
         /// </summary>
         protected virtual bool MessageRegistrationTiedToEnableStatus => true;
 
         protected bool _isQuitting;
 
-        protected virtual void Awake()
-        {
-            SetupMessageHandlers();
-        }
+        protected MessagingComponent _messagingComponent;
 
-        protected void SetupMessageHandlers()
+        protected virtual void Awake()
         {
-            if (_messageRegistrationToken == null)
-            {
-                MessagingComponent messenger = GetComponent<MessagingComponent>();
-                _messageRegistrationToken = messenger.Create(this);
-            }
-
+            _messagingComponent = GetComponent<MessagingComponent>();
+            _messageRegistrationToken = _messagingComponent.Create(this);
             RegisterMessageHandlers();
         }
 
         protected virtual void RegisterMessageHandlers()
         {
-            // No-op, expectation is that implementations implement their own logic here
+            _ = _messageRegistrationToken.RegisterGameObjectTargeted<StringMessage>(
+                gameObject,
+                HandleStringGameObjectMessage
+            );
+            _ = _messageRegistrationToken.RegisterComponentTargeted<StringMessage>(
+                this,
+                HandleStringComponentMessage
+            );
+            _ = _messageRegistrationToken.RegisterUntargeted<GlobalStringMessage>(
+                HandleGlobalStringMessage
+            );
         }
 
         protected virtual void OnEnable()
@@ -72,5 +78,20 @@
         {
             _isQuitting = true;
         }
+
+        protected virtual void HandleStringGameObjectMessage(ref StringMessage message)
+        {
+            // No-op by default
+        }
+
+        protected virtual void HandleStringComponentMessage(ref StringMessage message)
+        {
+            // No-op by default
+        }
+
+        protected virtual void HandleGlobalStringMessage(ref GlobalStringMessage message)
+        {
+            // No-op by default
+        }
     }
 }

package/Runtime/Unity/Messages/GlobalStringMessage.cs

@@ -0,0 +1,15 @@
+namespace DxMessaging.Unity.Messages
+{
+    using Core.Attributes;
+
+    [DxUntargetedMessage]
+    public readonly partial struct GlobalStringMessage
+    {
+        public readonly string message;
+
+        public GlobalStringMessage(string message)
+        {
+            this.message = message;
+        }
+    }
+}

package/Runtime/Unity/Messages/GlobalStringMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 58b2b780f9844aeb8929eeca855ba3be
+timeCreated: 1745161506

package/Runtime/Unity/Messages/StringMessage.cs

@@ -0,0 +1,15 @@
+namespace DxMessaging.Unity.Messages
+{
+    using Core.Attributes;
+
+    [DxTargetedMessage]
+    public readonly partial struct StringMessage
+    {
+        public readonly string message;
+
+        public StringMessage(string message)
+        {
+            this.message = message;
+        }
+    }
+}

package/Runtime/Unity/Messages/StringMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cf8206ca4c8449a8b8e112ad25554f1f
+timeCreated: 1745161457

package/Runtime/Unity/Messages.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1a132a737bb42a79205b2269554e818
+timeCreated: 1745160607

package/Runtime/WallstopStudios.DxMessaging.asmdef

@@ -4,7 +4,7 @@
     "references": [],
     "includePlatforms": [],
     "excludePlatforms": [],
-    "allowUnsafeCode": false,
+    "allowUnsafeCode": true,
     "overrideReferences": false,
     "precompiledReferences": [
         "System.Runtime.CompilerServices.Unsafe.dll"