com.wallstop-studios.dxmessaging 2.0.0-rc26 → 2.0.0-rc26.2

package/Editor/SetupCscRsp.cs

@@ -62,12 +62,7 @@ namespace DxMessaging.Editor
                     continue;
                 }
 
-                if (
-                    !dllPath.Contains(
-                        "Assets/Plugins/WallstopStudios.DxMessaging",
-                        StringComparison.OrdinalIgnoreCase
-                    )
-                )
+                if (!dllPath.Contains("Assets/Plugins", StringComparison.OrdinalIgnoreCase))
                 {
                     string dllName = Path.GetFileName(dllPath);
                     DllNames.Add(dllName);
@@ -95,10 +90,14 @@ namespace DxMessaging.Editor
                         }
 
                         const string pluginsDirectory =
-                            "Assets/Plugins/WallstopStudios.DxMessaging/";
+                            "Assets/Plugins/Editor/WallstopStudios.DxMessaging/";
                         string outputAsset = $"{pluginsDirectory}{requiredDllName}";
                         string sourceAsset = $"{relativeDirectory}{requiredDllName}";
-                        Directory.CreateDirectory(pluginsDirectory);
+                        if (!Directory.Exists(pluginsDirectory))
+                        {
+                            Directory.CreateDirectory(pluginsDirectory);
+                            AssetDatabase.Refresh();
+                        }
                         if (!File.Exists(outputAsset))
                         {
                             File.Copy(sourceAsset, outputAsset);

package/README.md

@@ -37,6 +37,8 @@ In addition to providing a richer feature set, DxMessaging is *faster* than Unit
 
 For UntargetedMessages, DxMessaging is significantly faster (roughly 2x) than Unity.
 
+## Windows
+
 | Message Tech | Operations / Second | Allocations? |
 | ------------ | ------------------- | ------------ | 
 | Unity | 2,649,000 | Yes |
@@ -49,6 +51,20 @@ For UntargetedMessages, DxMessaging is significantly faster (roughly 2x) than Un
 | Reflexive (Two Arguments) | 1,000,400 | No |
 | Reflexive (Three Arguments) | 993,800 | No |
 
+## Linux
+
+ Message Tech | Operations / Second | Allocations? |
+| ------------ | ------------------- | ------------ | 
+| Unity | 1,538,000 | Yes |
+| DxMessaging (GameObject) - Normal | 5,653,200 | No |
+| DxMessaging (Component) - Normal | 4,998,800 | No |
+| DxMessaging (GameObject) - No-Copy | 6,388,800 | No |
+| DxMessaging (Component) - No-Copy | 6,332,800 | No |
+| DxMessaging (Untargeted) - No-Copy | 9,805,200 | No |
+| Reflexive (One Argument) | 1,692,600 | No |
+| Reflexive (Two Arguments) | 1,348,000 | No |
+| Reflexive (Three Arguments) | 1,368,000 | No |
+
 # Functionality
 While not as fast, DxMessaging offers *additional functionality* as compared to Unity's messaging solution.
 | Feature | Unity | DxMessaging |

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -0,0 +1,265 @@
+namespace DxMessaging.Core.DataStructure
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using Extensions;
+
+    [Serializable]
+    internal sealed class CyclicBuffer<T> : IReadOnlyList<T>
+    {
+        public struct CyclicBufferEnumerator : IEnumerator<T>
+        {
+            private readonly CyclicBuffer<T> _buffer;
+
+            private int _index;
+            private T _current;
+
+            internal CyclicBufferEnumerator(CyclicBuffer<T> buffer)
+            {
+                _buffer = buffer;
+                _index = -1;
+                _current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (++_index < _buffer.Count)
+                {
+                    _current = _buffer._buffer[_buffer.AdjustedIndexFor(_index)];
+                    return true;
+                }
+
+                _current = default;
+                return false;
+            }
+
+            public T Current => _current;
+
+            object IEnumerator.Current => Current;
+
+            public void Reset()
+            {
+                _index = -1;
+                _current = default;
+            }
+
+            public void Dispose() { }
+        }
+
+        public int Capacity { get; private set; }
+        public int Count { get; private set; }
+
+        private readonly List<T> _buffer;
+        private int _position;
+
+        public T this[int index]
+        {
+            get
+            {
+                BoundsCheck(index);
+                return _buffer[AdjustedIndexFor(index)];
+            }
+            set
+            {
+                BoundsCheck(index);
+                _buffer[AdjustedIndexFor(index)] = value;
+            }
+        }
+
+        public CyclicBuffer(int capacity, IEnumerable<T> initialContents = null)
+        {
+            if (capacity < 0)
+            {
+                throw new ArgumentException(nameof(capacity));
+            }
+
+            Capacity = capacity;
+            _position = 0;
+            Count = 0;
+            _buffer = new List<T>();
+            if (initialContents != null)
+            {
+                foreach (T item in initialContents)
+                {
+                    Add(item);
+                }
+            }
+        }
+
+        public CyclicBufferEnumerator GetEnumerator()
+        {
+            return new CyclicBufferEnumerator(this);
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public void Add(T item)
+        {
+            if (Capacity == 0)
+            {
+                return;
+            }
+
+            if (_position < _buffer.Count)
+            {
+                _buffer[_position] = item;
+            }
+            else
+            {
+                _buffer.Add(item);
+            }
+
+            _position = (_position + 1) % Capacity;
+            if (Count < Capacity)
+            {
+                ++Count;
+            }
+        }
+
+        public bool Remove(T element, IEqualityComparer<T> comparer = null)
+        {
+            if (Count == 0)
+            {
+                return false;
+            }
+
+            int write = 0;
+            bool removed = false;
+            comparer ??= EqualityComparer<T>.Default;
+            for (int i = 0; i < Count; ++i)
+            {
+                int readIdx = AdjustedIndexFor(i);
+                T item = _buffer[readIdx];
+
+                if (!removed && comparer.Equals(item, element))
+                {
+                    removed = true;
+                    continue;
+                }
+
+                _buffer[write++] = item;
+            }
+
+            if (!removed)
+            {
+                return false;
+            }
+
+            _buffer.RemoveRange(write, _buffer.Count - write);
+
+            Count--;
+            _position = Count < Capacity ? Count : 0;
+            return true;
+        }
+
+        public int RemoveAll(Func<T, bool> predicate)
+        {
+            if (Count == 0)
+            {
+                return 0;
+            }
+
+            int write = 0;
+            int removedCount = 0;
+
+            for (int i = 0; i < Count; ++i)
+            {
+                int readIdx = AdjustedIndexFor(i);
+                T item = _buffer[readIdx];
+                if (predicate(item))
+                {
+                    removedCount++;
+                }
+                else
+                {
+                    _buffer[write++] = item;
+                }
+            }
+
+            if (removedCount == 0)
+            {
+                return 0;
+            }
+
+            _buffer.RemoveRange(write, _buffer.Count - write);
+            Count -= removedCount;
+            _position = Count < Capacity ? Count : 0;
+            return removedCount;
+        }
+
+        public void Clear()
+        {
+            Count = 0;
+            _position = 0;
+            _buffer.Clear();
+        }
+
+        public void Resize(int newCapacity)
+        {
+            if (newCapacity == Capacity)
+            {
+                return;
+            }
+
+            if (newCapacity < 0)
+            {
+                throw new ArgumentException(nameof(newCapacity));
+            }
+
+            int oldCapacity = Capacity;
+            Capacity = newCapacity;
+            _buffer.Shift(-_position);
+            if (newCapacity < _buffer.Count)
+            {
+                _buffer.RemoveRange(newCapacity, _buffer.Count - newCapacity);
+            }
+
+            _position =
+                newCapacity < oldCapacity && newCapacity <= _buffer.Count ? 0 : _buffer.Count;
+            Count = Math.Min(newCapacity, Count);
+        }
+
+        public bool Contains(T item)
+        {
+            return _buffer.Contains(item);
+        }
+
+        private int AdjustedIndexFor(int index)
+        {
+            long longCapacity = Capacity;
+            if (longCapacity == 0L)
+            {
+                return 0;
+            }
+            unchecked
+            {
+                int adjustedIndex = (int)(
+                    (_position - 1L + longCapacity - (_buffer.Count - 1 - index)) % longCapacity
+                );
+                return adjustedIndex;
+            }
+        }
+
+        private void BoundsCheck(int index)
+        {
+            if (!InBounds(index))
+            {
+                throw new IndexOutOfRangeException($"{index} is outside of bounds [0, {Count})");
+            }
+        }
+
+        private bool InBounds(int index)
+        {
+            return 0 <= index && index < Count;
+        }
+    }
+}

package/Runtime/Core/DataStructure/CyclicBuffer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7d8dbf8640e24846bf35fb18a1b7c504
+timeCreated: 1749671893

package/Runtime/Core/DataStructure.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9862044472704c86ade5612ddcdfd5b5
+timeCreated: 1749671887

package/Runtime/Core/Diagnostics/MessageEmissionData.cs

@@ -0,0 +1,53 @@
+namespace DxMessaging.Core.Diagnostics
+{
+    using System;
+#if UNITY_2017_1_OR_NEWER
+    using UnityEngine;
+#endif
+
+    public readonly struct MessageEmissionData
+    {
+        private static readonly string[] NewlineSeparators = { "\r\n", "\n", "\r" };
+        private static readonly string JoinSeparator = Environment.NewLine;
+
+        public readonly IMessage message;
+        public readonly InstanceId? context;
+        public readonly string stackTrace;
+
+        public MessageEmissionData(IMessage message, InstanceId? context = null)
+        {
+            this.message = message;
+            this.context = context;
+            stackTrace = GetAccurateStackTrace();
+        }
+
+        private static string GetAccurateStackTrace()
+        {
+            string fullStackTrace;
+#if UNITY_2017_1_OR_NEWER
+            fullStackTrace = StackTraceUtility.ExtractStackTrace();
+#else
+            fullStackTrace = new StackTrace(true).ToString();
+#endif
+            if (string.IsNullOrWhiteSpace(fullStackTrace))
+            {
+                return fullStackTrace;
+            }
+
+            string[] lines = fullStackTrace.Split(NewlineSeparators, StringSplitOptions.None);
+
+            int startIndex = 1;
+            while (
+                startIndex < lines.Length
+                && lines[startIndex].Contains("DxMessaging", StringComparison.OrdinalIgnoreCase)
+            )
+            {
+                ++startIndex;
+            }
+
+            return lines.Length <= startIndex
+                ? string.Empty
+                : string.Join(JoinSeparator, lines, startIndex, lines.Length - startIndex);
+        }
+    }
+}

package/Runtime/Core/Diagnostics/MessageEmissionData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8eafaabae0f549ec82f67ea18be788e1
+timeCreated: 1749672335

package/Runtime/Core/Diagnostics/MessageRegistrationData.cs

@@ -0,0 +1,25 @@
+namespace DxMessaging.Core.Diagnostics
+{
+    using System;
+
+    public readonly struct MessageRegistrationMetadata
+    {
+        public readonly InstanceId? context;
+        public readonly MessageRegistrationType registrationType;
+        public readonly Type type;
+        public readonly int priority;
+
+        public MessageRegistrationMetadata(
+            InstanceId? context,
+            Type type,
+            MessageRegistrationType registrationType,
+            int priority
+        )
+        {
+            this.context = context;
+            this.type = type;
+            this.registrationType = registrationType;
+            this.priority = priority;
+        }
+    }
+}

package/Runtime/Core/Diagnostics/MessageRegistrationData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 01598791b01241caabfecea4c1f5880d
+timeCreated: 1749672447

package/Runtime/Core/Diagnostics/MessageRegistrationType.cs

@@ -0,0 +1,21 @@
+namespace DxMessaging.Core.Diagnostics
+{
+    public enum MessageRegistrationType
+    {
+        None = 0,
+        Targeted = 1,
+        Untargeted = 2,
+        Broadcast = 3,
+        BroadcastPostProcessor = 4,
+        TargetedPostProcessor = 5,
+        TargetedWithoutTargeting = 6,
+        TargetedWithoutTargetingPostProcessor = 7,
+        BroadcastWithoutSource = 8,
+        BroadcastWithoutSourcePostProcessor = 9,
+        UntargetedPostProcessor = 10,
+        GlobalAcceptAll = 11,
+        UntargetedInterceptor = 12,
+        TargetedInterceptor = 13,
+        BroadcastInterceptor = 14,
+    }
+}

package/Runtime/Core/Diagnostics/MessageRegistrationType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7d393cfbb3c8429d83af17a737fdaf0e
+timeCreated: 1749672471

package/Runtime/Core/Diagnostics.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9606a03ced274c3888a4d993309786a4
+timeCreated: 1749672323

package/Runtime/Core/Extensions/IListExtensions.cs

@@ -0,0 +1,48 @@
+namespace DxMessaging.Core.Extensions
+{
+    using System;
+    using System.Collections.Generic;
+
+    internal static class IListExtensions
+    {
+        public static void Shift<T>(this IList<T> list, int amount)
+        {
+            if (list is not { Count: > 1 })
+            {
+                return;
+            }
+
+            int count = list.Count;
+            amount %= count;
+            amount += count;
+            amount %= count;
+            if (amount == 0)
+            {
+                return;
+            }
+
+            Reverse(list, 0, count - 1);
+            Reverse(list, 0, amount - 1);
+            Reverse(list, amount, count - 1);
+        }
+
+        public static void Reverse<T>(this IList<T> list, int start, int end)
+        {
+            if (start < 0 || list.Count <= start)
+            {
+                throw new ArgumentException(nameof(start));
+            }
+            if (end < 0 || list.Count <= end)
+            {
+                throw new ArgumentException(nameof(end));
+            }
+
+            while (start < end)
+            {
+                (list[start], list[end]) = (list[end], list[start]);
+                start++;
+                end--;
+            }
+        }
+    }
+}

package/Runtime/Core/Extensions/IListExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f6956caef19744a0b0d96215d4e5154a
+timeCreated: 1749671953

package/Runtime/Core/Extensions/MessageExtensions.cs

@@ -174,6 +174,24 @@
             messageBus.UntargetedBroadcast(ref message);
         }
 
+        /// <summary>
+        /// Emits an UntargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">UntargetedMessage to emit.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void Emit<TMessage>(this TMessage message, IMessageBus messageBus = null)
+            where TMessage : class, IUntargetedMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) == typeof(IUntargetedMessage))
+            {
+                messageBus.UntypedUntargetedBroadcast(message);
+                return;
+            }
+
+            messageBus.UntargetedBroadcast(ref message);
+        }
+
         /// <summary>
         /// Emits an UntargetedMessage of the given type.
         /// </summary>
@@ -195,6 +213,24 @@
             messageBus.UntargetedBroadcast(ref message);
         }
 
+        /// <summary>
+        /// Emits an UntargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">UntargetedMessage to emit.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void Emit<TMessage>(this ref TMessage message, IMessageBus messageBus = null)
+            where TMessage : struct, IUntargetedMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) == typeof(IUntargetedMessage))
+            {
+                messageBus.UntypedUntargetedBroadcast(message);
+                return;
+            }
+
+            messageBus.UntargetedBroadcast(ref message);
+        }
+
 #if UNITY_2017_1_OR_NEWER
         /// <summary>
         /// Emits a BroadcastMessage of the given type.
@@ -338,5 +374,35 @@
 
             messageBus.SourcedBroadcast(ref source, ref message);
         }
+
+        /// <summary>
+        /// Emits a StringMessage at the target containing the provided string.
+        /// </summary>
+        /// <param name="message">Message to send to the target.</param>
+        /// <param name="target">Target to send the message to.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void Emit(
+            this string message,
+            InstanceId target,
+            IMessageBus messageBus = null
+        )
+        {
+            StringMessage stringMessage = new(message);
+            (messageBus ?? MessageHandler.MessageBus).TargetedBroadcast(
+                ref target,
+                ref stringMessage
+            );
+        }
+
+        /// <summary>
+        /// Emits a GlobalStringMessage containing the provided string.
+        /// </summary>
+        /// <param name="message">Message to send globally.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void Emit(this string message, IMessageBus messageBus = null)
+        {
+            GlobalStringMessage stringMessage = new(message);
+            (messageBus ?? MessageHandler.MessageBus).UntargetedBroadcast(ref stringMessage);
+        }
     }
 }

package/Runtime/Core/MessageBus/IMessageBus.cs

@@ -10,11 +10,16 @@
     /// </summary>
     public interface IMessageBus
     {
+        public static bool GlobalDiagnosticsMode { get; set; }
+        public static int GlobalMessageBufferSize { get; set; }
+
         internal static int GlobalSequentialIndex = -1;
 
         protected static int GenerateNewGlobalSequentialIndex() =>
             Interlocked.Increment(ref GlobalSequentialIndex);
 
+        public bool DiagnosticsMode { get; }
+
         public int RegisteredGlobalSequentialIndex { get; }
         public int RegisteredBroadcast { get; }
 
@@ -283,7 +288,6 @@
         /// Broadcasts a fast Untargeted message to all listeners registered to this bus.
         /// </summary>
         /// <param name="typedMessage">Message to broadcast.</param>
-
         void UntargetedBroadcast<TMessage>(ref TMessage typedMessage)
             where TMessage : IUntargetedMessage;
 
@@ -299,7 +303,6 @@
         /// </summary>
         /// <param name="target">Target to send the message to.</param>
         /// <param name="typedMessage">Message to broadcast.</param>
-
         void TargetedBroadcast<TMessage>(ref InstanceId target, ref TMessage typedMessage)
             where TMessage : ITargetedMessage;
 
@@ -315,7 +318,6 @@
         /// </summary>
         /// <param name="source">Source of the message.</param>
         /// <param name="typedMessage">Message to broadcast.</param>
-
         void SourcedBroadcast<TMessage>(ref InstanceId source, ref TMessage typedMessage)
             where TMessage : IBroadcastMessage;
     }