com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

package/Runtime/Core/InstanceId.cs

@@ -50,10 +50,34 @@ namespace DxMessaging.Core
 #if UNITY_2021_3_OR_NEWER
         private InstanceId(UnityEngine.Object unityObject)
         {
-            _id = unityObject.GetInstanceID();
+            _id = StableId(unityObject);
             Object = unityObject;
         }
 
+        /// <summary>
+        /// Returns the stable per-object integer identity used as the dispatch key.
+        /// Unity 6 is migrating object identity to the 64-bit <c>EntityId</c>:
+        /// <c>GetInstanceID()</c> is deprecated and becomes a compile error in Unity 6.5,
+        /// and successive raw accessors (the <c>EntityId</c>-to-<c>int</c> cast, then
+        /// <c>GetRawData()</c>) have each been deprecated in turn. On Unity 6.4+ this reads
+        /// the non-deprecated <c>EntityId.ToULong(...)</c> and keeps its low 32 bits --
+        /// exactly the integer the legacy <c>GetInstanceID()</c> returned (verified on 6.4
+        /// across GameObject/Component/ScriptableObject). Older Unity keeps
+        /// <c>GetInstanceID()</c> (valid, warning-only there, never the 6.5 error). The
+        /// 32-bit dispatch key is identical either way; only the (non-deprecated) source
+        /// differs. The gate is the host-verified 6.4 rather than 6.2 because the exact
+        /// accessor that is non-deprecated has shifted across Unity 6 minors.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static int StableId(UnityEngine.Object unityObject)
+        {
+#if UNITY_6000_4_OR_NEWER
+            return unchecked((int)UnityEngine.EntityId.ToULong(unityObject.GetEntityId()));
+#else
+            return unityObject.GetInstanceID();
+#endif
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         /// <summary>
         /// Converts a <see cref="UnityEngine.GameObject"/> reference into an <see cref="InstanceId"/>.

package/Runtime/Core/InstanceId.cs.meta

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

package/Runtime/Core/Internal/DxUnsafe.cs

@@ -0,0 +1,60 @@
+namespace DxMessaging.Core.Internal
+{
+    using System.Runtime.CompilerServices;
+    // Qualified with global:: because this assembly also declares a DxMessaging.Unity
+    // namespace; an unqualified "using Unity.Collections..." would bind to
+    // DxMessaging.Unity.Collections and fail to resolve.
+    using global::Unity.Collections.LowLevel.Unsafe;
+
+    /// <summary>
+    /// Reinterpret-cast helpers used by the hot dispatch path. Each method wraps a Unity
+    /// <see cref="UnsafeUtility"/> intrinsic, which resolves in both the Editor and every
+    /// player build (Mono and IL2CPP, including the .NET Standard 2.0 profile) without an
+    /// external precompiled assembly.
+    /// </summary>
+    /// <remarks>
+    /// These are drop-in replacements for the corresponding
+    /// <c>System.Runtime.CompilerServices.Unsafe</c> members. That type is supplied by the
+    /// Editor but is absent from player builds, so referencing it compiled in the Editor yet
+    /// failed standalone IL2CPP compilation. <see cref="UnsafeUtility"/> ships inside
+    /// <c>UnityEngine.CoreModule</c> on every supported platform, so routing through it keeps
+    /// the zero-allocation reinterpret behavior while removing the unresolved dependency.
+    /// The wrapped intrinsics are pure IL (no internal-call transition), so this indirection
+    /// is free once inlined.
+    /// </remarks>
+    internal static class DxUnsafe
+    {
+        /// <summary>
+        /// Reinterprets a managed reference to <typeparamref name="TFrom"/> as a reference to
+        /// <typeparamref name="TTo"/> in place, without copying or boxing. Callers guarantee the
+        /// reinterpretation is valid for the concrete runtime layout.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static ref TTo As<TFrom, TTo>(ref TFrom source)
+        {
+            return ref UnsafeUtility.As<TFrom, TTo>(ref source);
+        }
+
+        /// <summary>
+        /// Reinterprets a reference-typed instance as <typeparamref name="TTo"/> without a type
+        /// check. Callers guarantee the runtime type, mirroring the prior unchecked
+        /// <c>Unsafe.As&lt;T&gt;(object)</c> usage.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static TTo As<TTo>(object value)
+            where TTo : class
+        {
+            return UnsafeUtility.As<object, TTo>(ref value);
+        }
+
+        /// <summary>
+        /// Returns the size in bytes of <typeparamref name="T"/>.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static int SizeOf<T>()
+            where T : struct
+        {
+            return UnsafeUtility.SizeOf<T>();
+        }
+    }
+}

package/Runtime/Core/Internal/DxUnsafe.cs.meta

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

package/Runtime/Core/Internal/FlatDispatch.cs

@@ -0,0 +1,198 @@
+namespace DxMessaging.Core.Internal
+{
+    using System;
+    using System.Buffers;
+    using System.Collections.Generic;
+    using DxMessaging.Core;
+
+    /// <summary>
+    /// One fully-resolved dispatch entry for slots whose delegates do NOT
+    /// receive the routing context (untargeted handle/post, and the
+    /// context-keyed Default-variant targeted/broadcast slots, where the
+    /// target/source is the routing key rather than a delegate parameter):
+    /// the owning <see cref="MessageHandler"/> (for the single live
+    /// <c>active</c> check) plus the final invocable delegate, resolved at
+    /// snapshot-build time. Steady-state dispatch over an array of these is
+    /// a single field read, one branch, and a direct delegate invocation per
+    /// entry - no dispatch link, no generation guard, no per-priority
+    /// dictionary lookup, and no type test.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal readonly struct FlatDispatchEntry<TMessage>
+        where TMessage : IMessage
+    {
+        public FlatDispatchEntry(
+            MessageHandler handler,
+            MessageHandler.FastHandler<TMessage> invoker
+        )
+        {
+            this.handler = handler;
+            this.invoker = invoker;
+        }
+
+        public readonly MessageHandler handler;
+        public readonly MessageHandler.FastHandler<TMessage> invoker;
+    }
+
+    /// <summary>
+    /// One fully-resolved dispatch entry for the WithoutContext
+    /// targeted/broadcast slots, whose delegates DO receive the routing
+    /// context (target/source <see cref="InstanceId"/>) as a parameter.
+    /// Mirrors <see cref="FlatDispatchEntry{TMessage}"/> with the
+    /// context-carrying delegate shape.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal readonly struct ContextFlatDispatchEntry<TMessage>
+        where TMessage : IMessage
+    {
+        public ContextFlatDispatchEntry(
+            MessageHandler handler,
+            MessageHandler.FastHandlerWithContext<TMessage> invoker
+        )
+        {
+            this.handler = handler;
+            this.invoker = invoker;
+        }
+
+        public readonly MessageHandler handler;
+        public readonly MessageHandler.FastHandlerWithContext<TMessage> invoker;
+    }
+
+    /// <summary>
+    /// Non-generic erasure base so the non-generic
+    /// <c>MessageBus.DispatchSnapshot</c> can carry and release a typed flat
+    /// entry array without knowing the closed message type (or the entry
+    /// shape). The snapshot's pooled-release path calls <see cref="Release"/>
+    /// exactly once per snapshot teardown; the typed holder returns its array
+    /// to the per-closed-generic pool.
+    /// </summary>
+    internal abstract class FlatDispatchArray
+    {
+        internal abstract void Release();
+    }
+
+    /// <summary>
+    /// Shared pooled-holder implementation for flat dispatch arrays: a pooled
+    /// entry array (rented from <see cref="ArrayPool{T}"/>) plus a small
+    /// per-closed-generic holder stack so registration-churn rebuilds
+    /// allocate nothing in steady state. Concrete holders
+    /// (<see cref="FlatDispatch{TMessage}"/>,
+    /// <see cref="ContextFlatDispatch{TMessage}"/>) only pick the entry
+    /// shape; all lifecycle logic lives here so the pool/lock/cap/released
+    /// pattern exists exactly once.
+    /// </summary>
+    /// <remarks>
+    /// Lifecycle mirrors the snapshot that owns the holder: the array is
+    /// frozen for the duration of any emission that acquired it (mutations
+    /// mark the owning DispatchState dirty and are observed by the NEXT
+    /// emission's rebuild), and it is released back to the pool only through
+    /// <c>DispatchSnapshot.Release()</c>. The <c>_released</c> flag guards
+    /// the holder against double-release (which would seat the same holder
+    /// in the pool twice and corrupt later rents): DEBUG builds assert,
+    /// release builds no-op the second call.
+    /// </remarks>
+    /// <typeparam name="TEntry">Resolved entry struct stored in the array.</typeparam>
+    /// <typeparam name="THolder">Concrete holder type (CRTP, for typed pooling).</typeparam>
+    internal abstract class PooledFlatDispatch<TEntry, THolder> : FlatDispatchArray
+        where THolder : PooledFlatDispatch<TEntry, THolder>, new()
+    {
+        private static readonly ArrayPool<TEntry> EntryPool = ArrayPool<TEntry>.Shared;
+
+        // Cold-path pool (rebuild/teardown only); the lock is uncontended in
+        // practice but keeps the holder pool safe if multiple buses are ever
+        // driven from different threads.
+        private static readonly Stack<THolder> HolderPool = new();
+        private static readonly object HolderPoolLock = new();
+        private const int MaxRetainedHolders = 64;
+
+        internal TEntry[] entries = Array.Empty<TEntry>();
+        internal int count;
+
+        // True while the holder is parked in (or eligible for) the pool;
+        // false while it is owned by a live DispatchSnapshot. Guards the
+        // rent/release lifecycle against double-release and rent-of-live.
+        private bool _released = true;
+
+        internal static THolder Rent(int capacity)
+        {
+            THolder holder = null;
+            lock (HolderPoolLock)
+            {
+                if (0 < HolderPool.Count)
+                {
+                    holder = HolderPool.Pop();
+                }
+            }
+
+            holder ??= new THolder();
+            System.Diagnostics.Debug.Assert(
+                holder._released,
+                "PooledFlatDispatch.Rent returned a holder that is still owned by a live "
+                    + "snapshot; a Release() was skipped or the pool was corrupted."
+            );
+            holder._released = false;
+            holder.entries = 0 < capacity ? EntryPool.Rent(capacity) : Array.Empty<TEntry>();
+            holder.count = 0;
+            return holder;
+        }
+
+        internal sealed override void Release()
+        {
+            if (_released)
+            {
+                System.Diagnostics.Debug.Assert(
+                    false,
+                    "PooledFlatDispatch.Release called twice on the same holder; the owning "
+                        + "DispatchSnapshot must release its flat array exactly once."
+                );
+                return;
+            }
+
+            _released = true;
+            TEntry[] localEntries = entries;
+            int localCount = count;
+            entries = Array.Empty<TEntry>();
+            count = 0;
+            if (0 < localEntries.Length)
+            {
+                Array.Clear(localEntries, 0, localCount);
+                EntryPool.Return(localEntries);
+            }
+
+            lock (HolderPoolLock)
+            {
+                if (HolderPool.Count < MaxRetainedHolders)
+                {
+                    HolderPool.Push((THolder)this);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Pooled flat array of resolved entries for one
+    /// (bus, message-type[, context], phase) dispatch snapshot whose
+    /// delegates take only the message: untargeted handle/post and the
+    /// context-keyed (Default variant) targeted/broadcast handle/post slots.
+    /// Built at snapshot-build time by walking the bus priority buckets
+    /// ascending, then each bucket's MessageHandlers in bus insertion order,
+    /// then each handler's fast entries followed by its default entries
+    /// (both in first-registration order), so a plain forward iteration
+    /// reproduces the documented dispatch order exactly.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal sealed class FlatDispatch<TMessage>
+        : PooledFlatDispatch<FlatDispatchEntry<TMessage>, FlatDispatch<TMessage>>
+        where TMessage : IMessage { }
+
+    /// <summary>
+    /// Pooled flat array of resolved entries for one (bus, message-type,
+    /// phase) dispatch snapshot of a WithoutContext targeted/broadcast slot,
+    /// whose delegates receive the routing <see cref="InstanceId"/> alongside
+    /// the message. Build order matches <see cref="FlatDispatch{TMessage}"/>.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal sealed class ContextFlatDispatch<TMessage>
+        : PooledFlatDispatch<ContextFlatDispatchEntry<TMessage>, ContextFlatDispatch<TMessage>>
+        where TMessage : IMessage { }
+}

package/Runtime/Core/Internal/FlatDispatch.cs.meta

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

package/Runtime/Core/Internal/TypedGlobalSlotIndex.cs

@@ -0,0 +1,38 @@
+namespace DxMessaging.Core.Internal
+{
+    /// <summary>
+    /// Const-int positions into <c>TypedHandler&lt;T&gt;._globalSlots[]</c>.
+    /// Indices are hand-written so call sites inline as immediate operands.
+    /// Array length and per-index <c>null</c>-ness are validated in DEBUG
+    /// builds via <c>TypedHandler&lt;T&gt;.ValidateSlotArrays()</c>.
+    /// </summary>
+    /// <remarks>
+    /// Positions are laid out in lex-(<c>Kind</c>, <c>Variant</c>) order:
+    /// Untargeted -&gt; Targeted -&gt; Broadcast within Kind, Default before
+    /// Fast within Variant. The xmldoc on each constant names the legacy
+    /// <c>TypedHandler&lt;T&gt;</c> field whose storage role the slot will
+    /// assume in typed global storage.
+    /// </remarks>
+    internal static class TypedGlobalSlotIndex
+    {
+        /// <summary>Legacy field: <c>_globalUntargetedHandlers</c>.</summary>
+        public const int UntargetedDefault = 0;
+
+        /// <summary>Legacy field: <c>_globalUntargetedFastHandlers</c>.</summary>
+        public const int UntargetedFast = 1;
+
+        /// <summary>Legacy field: <c>_globalTargetedHandlers</c>.</summary>
+        public const int TargetedDefault = 2;
+
+        /// <summary>Legacy field: <c>_globalTargetedFastHandlers</c>.</summary>
+        public const int TargetedFast = 3;
+
+        /// <summary>Legacy field: <c>_globalBroadcastHandlers</c>.</summary>
+        public const int BroadcastDefault = 4;
+
+        /// <summary>Legacy field: <c>_globalBroadcastFastHandlers</c>.</summary>
+        public const int BroadcastFast = 5;
+
+        public const int Length = 6;
+    }
+}

package/Runtime/Core/Internal/TypedGlobalSlotIndex.cs.meta

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

package/Runtime/Core/Internal/TypedSlotIndex.cs

@@ -0,0 +1,81 @@
+namespace DxMessaging.Core.Internal
+{
+    /// <summary>
+    /// Const-int positions into <c>TypedHandler&lt;T&gt;._slots[]</c>. Indices
+    /// are hand-written so call sites inline as immediate operands. Array
+    /// length and per-index <c>null</c>-ness are validated in DEBUG builds via
+    /// <c>TypedHandler&lt;T&gt;.ValidateSlotArrays()</c>.
+    /// </summary>
+    /// <remarks>
+    /// Positions are laid out in lex-(<c>Kind</c>, <c>Phase</c>, <c>Variant</c>) order:
+    /// Untargeted -&gt; Targeted -&gt; Broadcast within Kind; Handle before
+    /// PostProcess within Phase; and Default -&gt; Fast -&gt; WithoutContext -&gt;
+    /// WithoutContextFast within Variant. The xmldoc on each constant names
+    /// the legacy <c>TypedHandler&lt;T&gt;</c> field whose storage role the
+    /// slot assumes in typed storage.
+    /// </remarks>
+    internal static class TypedSlotIndex
+    {
+        /// <summary>Legacy field: <c>_untargetedHandlers</c>.</summary>
+        public const int UntargetedHandleDefault = 0;
+
+        /// <summary>Legacy field: <c>_untargetedFastHandlers</c>.</summary>
+        public const int UntargetedHandleFast = 1;
+
+        /// <summary>Legacy field: <c>_untargetedPostProcessingHandlers</c>.</summary>
+        public const int UntargetedPostProcessDefault = 2;
+
+        /// <summary>Legacy field: <c>_untargetedPostProcessingFastHandlers</c>.</summary>
+        public const int UntargetedPostProcessFast = 3;
+
+        /// <summary>Legacy field: <c>_targetedHandlers</c>.</summary>
+        public const int TargetedHandleDefault = 4;
+
+        /// <summary>Legacy field: <c>_targetedFastHandlers</c>.</summary>
+        public const int TargetedHandleFast = 5;
+
+        /// <summary>Legacy field: <c>_targetedWithoutTargetingHandlers</c>.</summary>
+        public const int TargetedHandleWithoutContext = 6;
+
+        /// <summary>Legacy field: <c>_fastTargetedWithoutTargetingHandlers</c>.</summary>
+        public const int TargetedHandleWithoutContextFast = 7;
+
+        /// <summary>Legacy field: <c>_targetedPostProcessingHandlers</c>.</summary>
+        public const int TargetedPostProcessDefault = 8;
+
+        /// <summary>Legacy field: <c>_targetedPostProcessingFastHandlers</c>.</summary>
+        public const int TargetedPostProcessFast = 9;
+
+        /// <summary>Legacy field: <c>_targetedWithoutTargetingPostProcessingHandlers</c>.</summary>
+        public const int TargetedPostProcessWithoutContext = 10;
+
+        /// <summary>Legacy field: <c>_fastTargetedWithoutTargetingPostProcessingHandlers</c>.</summary>
+        public const int TargetedPostProcessWithoutContextFast = 11;
+
+        /// <summary>Legacy field: <c>_broadcastHandlers</c>.</summary>
+        public const int BroadcastHandleDefault = 12;
+
+        /// <summary>Legacy field: <c>_broadcastFastHandlers</c>.</summary>
+        public const int BroadcastHandleFast = 13;
+
+        /// <summary>Legacy field: <c>_broadcastWithoutSourceHandlers</c>.</summary>
+        public const int BroadcastHandleWithoutContext = 14;
+
+        /// <summary>Legacy field: <c>_fastBroadcastWithoutSourceHandlers</c>.</summary>
+        public const int BroadcastHandleWithoutContextFast = 15;
+
+        /// <summary>Legacy field: <c>_broadcastPostProcessingHandlers</c>.</summary>
+        public const int BroadcastPostProcessDefault = 16;
+
+        /// <summary>Legacy field: <c>_broadcastPostProcessingFastHandlers</c>.</summary>
+        public const int BroadcastPostProcessFast = 17;
+
+        /// <summary>Legacy field: <c>_broadcastWithoutSourcePostProcessingHandlers</c>.</summary>
+        public const int BroadcastPostProcessWithoutContext = 18;
+
+        /// <summary>Legacy field: <c>_fastBroadcastWithoutSourcePostProcessingHandlers</c>.</summary>
+        public const int BroadcastPostProcessWithoutContextFast = 19;
+
+        public const int Length = 20;
+    }
+}

package/Runtime/Core/Internal/TypedSlotIndex.cs.meta

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