Update DelegateMQ library

Author: endurodave

DelegateMQ/Common.cmake

@@ -8,6 +8,10 @@ if (MSVC)
     add_compile_options("/utf-8")
     add_compile_definitions(_SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING)
     add_compile_definitions(_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS)
+
+    # Fix for spdlog bundled fmt in C++20 mode
+    add_compile_definitions(FMT_USE_ITERATOR_TRAITS=1)
+    add_compile_definitions(FMT_MSVC_CRT_ITERATORS=0)
 endif()
 
 

DelegateMQ/Port.cmake

@@ -132,20 +132,25 @@ endif()
 if (DMQ_UTIL STREQUAL "ON")
     if (DMQ_THREAD STREQUAL "DMQ_THREAD_NONE")
         # Bare metal: Only include utilities that DON'T need mutexes
-        file(GLOB UTIL_SOURCES 
-            "${DMQ_ROOT_DIR}/extras/util/Fault.c*" 
+        # Fault.cpp lives in port/fault/ and is always included separately
+        file(GLOB UTIL_SOURCES
             "${DMQ_ROOT_DIR}/extras/util/Fault.h"
             # Explicitly exclude Timer.cpp and AsyncInvoke.cpp
         )
     else()
-        # OS/RTOS present: Include everything
-        file(GLOB UTIL_SOURCES 
-            "${DMQ_ROOT_DIR}/extras/util/*.c*" 
-            "${DMQ_ROOT_DIR}/extras/util/*.h" 
+        # OS/RTOS present: Include everything 
+        file(GLOB UTIL_SOURCES
+            "${DMQ_ROOT_DIR}/extras/util/*.c*"
+            "${DMQ_ROOT_DIR}/extras/util/*.h"
         )
     endif()
 endif()
 
+# Fault handler port — always included; override by filtering Fault.cpp from DMQ_PORT_SOURCES
+file(GLOB FAULT_SOURCES
+    "${DMQ_ROOT_DIR}/port/fault/Fault.cpp"
+)
+
 if (DMQ_ASSERTS STREQUAL "ON")
     add_compile_definitions(DMQ_ASSERTS)
 endif()
@@ -160,6 +165,7 @@ list(APPEND DMQ_PORT_ONLY_SOURCES ${TRANSPORT_SOURCES})
 list(APPEND DMQ_PORT_ONLY_SOURCES ${SERIALIZE_SOURCES})
 list(APPEND DMQ_PORT_ONLY_SOURCES ${THREAD_SOURCES})
 list(APPEND DMQ_PORT_ONLY_SOURCES ${OS_SOURCES})
+list(APPEND DMQ_PORT_ONLY_SOURCES ${FAULT_SOURCES})
 
 # Extras sources: optional higher-level infrastructure (extras/ directory)
 set(DMQ_EXTRAS_SOURCES "")

DelegateMQ/delegate/DelegateMQConfig_Default.h

@@ -0,0 +1,40 @@
+#ifndef _DELEGATEMQ_CONFIG_DEFAULT_H
+#define _DELEGATEMQ_CONFIG_DEFAULT_H
+
+/// @file
+/// @brief Default DelegateMQ library configuration.
+///
+/// To override, define DMQ_USER_CONFIG as a path to your own config header:
+///   -DDMQ_USER_CONFIG="path/to/DelegateMQConfig.h"
+/// Your config only needs to define the values you want to change.
+/// Unset values fall back to these defaults via DelegateMQConfig_Default.h.
+
+#ifndef DMQ_DEFAULT_DISPATCH_TIMEOUT
+    #define DMQ_DEFAULT_DISPATCH_TIMEOUT    2       // seconds
+#endif
+
+#ifndef DMQ_MAX_TIMER_EXPIRED
+    #define DMQ_MAX_TIMER_EXPIRED           16
+#endif
+
+#ifndef DMQ_SIGNAL_SBO_COUNT
+    #define DMQ_SIGNAL_SBO_COUNT            8
+#endif
+
+#ifndef DMQ_DEFAULT_QUEUE_SIZE
+    #define DMQ_DEFAULT_QUEUE_SIZE          20
+#endif
+
+#ifndef DMQ_MAX_WATCHDOG_THREADS
+    #define DMQ_MAX_WATCHDOG_THREADS        16
+#endif
+
+#ifndef DMQ_SEQ_HISTORY_SIZE
+    #define DMQ_SEQ_HISTORY_SIZE            8
+#endif
+
+#ifndef DMQ_MAX_PARTICIPANTS
+    #define DMQ_MAX_PARTICIPANTS            8
+#endif
+
+#endif // _DELEGATEMQ_CONFIG_DEFAULT_H

DelegateMQ/delegate/DelegateMQConfig_Template.h

@@ -0,0 +1,36 @@
+#ifndef _DELEGATEMQ_CONFIG_H
+#define _DELEGATEMQ_CONFIG_H
+
+/// @file
+/// @brief User configuration for the DelegateMQ library.
+///
+/// Copy this file to your project, then point the compiler at it:
+///   -DDMQ_USER_CONFIG="DelegateMQConfig.h"
+///
+/// Only define the values you want to change; any omitted values
+/// fall back to the defaults in DelegateMQConfig_Default.h.
+
+/// Timeout (seconds) used by the TIMEOUT queue-full policy on all threads.
+#define DMQ_DEFAULT_DISPATCH_TIMEOUT    2
+
+/// Max timers processed in one tick without heap allocation.
+#define DMQ_MAX_TIMER_EXPIRED           16
+
+/// Signal Small-Buffer Optimization count.
+/// Signals with <= this many subscribers are invoked without heap allocation.
+#define DMQ_SIGNAL_SBO_COUNT            8
+
+/// Default internal message queue depth for all dmq::os::Thread ports.
+#define DMQ_DEFAULT_QUEUE_SIZE          20
+
+/// Max number of threads that can be registered with the watchdog.
+#define DMQ_MAX_WATCHDOG_THREADS        16
+
+/// Duplicate-detection ring buffer depth per remote Participant.
+/// Larger values catch more out-of-order duplicates; reduce on RAM-constrained targets.
+#define DMQ_SEQ_HISTORY_SIZE            8
+
+/// Max number of remote Participants the DataBus can hold without heap allocation.
+#define DMQ_MAX_PARTICIPANTS            8
+
+#endif // _DELEGATEMQ_CONFIG_H

DelegateMQ/delegate/DelegateOpt.h

@@ -4,6 +4,13 @@
 /// @file
 /// @brief Delegate library options header file.
 
+// Pull in user config if provided, otherwise use library defaults.
+// To provide your own config: -DDMQ_USER_CONFIG="path/to/DelegateMQConfig.h"
+#ifdef DMQ_USER_CONFIG
+    #include DMQ_USER_CONFIG
+#endif
+#include "DelegateMQConfig_Default.h"
+
 #if defined(_WIN32) || defined(_WIN64)
     #ifndef WIN32_LEAN_AND_MEAN
         #define WIN32_LEAN_AND_MEAN
@@ -59,7 +66,9 @@
 #endif
 
 #include <chrono>
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || \
+    defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_THREADX) || \
+    defined(DMQ_THREAD_ZEPHYR) || defined(DMQ_THREAD_CMSIS_RTOS2)
     #include <mutex>
 #endif
 
@@ -72,12 +81,10 @@
     // Windows / Linux / macOS / Qt (Standard Library)
     #include <condition_variable>
 #elif defined(DMQ_THREAD_FREERTOS)
-    #include <mutex>
     #include "port/os/freertos/FreeRTOSClock.h"
     #include "port/os/freertos/FreeRTOSMutex.h"
     #include "port/os/freertos/FreeRTOSConditionVariable.h"
 #elif defined(DMQ_THREAD_THREADX)
-    #include <mutex>
     #include "port/os/threadx/ThreadXClock.h"
     #include "port/os/threadx/ThreadXMutex.h"
     #include "port/os/threadx/ThreadXConditionVariable.h"
@@ -107,6 +114,28 @@ namespace dmq
         PortableLockGuard& operator=(const PortableLockGuard&) = delete;
     };
 
+    // --- PORTABLE SCOPED LOCK ---
+    // Maps to std::scoped_lock on all known threaded ports (desktop + RTOS).
+    // All RTOS mutex types satisfy BasicLockable (lock/unlock), so std::scoped_lock
+    // works with them directly. Falls back to a no-op for DMQ_THREAD_NONE and for
+    // any unrecognized bare-metal build where no thread model is defined.
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || \
+    defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_THREADX) || \
+    defined(DMQ_THREAD_ZEPHYR) || defined(DMQ_THREAD_CMSIS_RTOS2)
+    template <typename... M>
+    using ScopedLock = std::scoped_lock<M...>;
+#else
+    // No-op: DMQ_THREAD_NONE or no thread model defined (bare-metal, single-threaded)
+    template <typename... M>
+    class ScopedLock {
+    public:
+        explicit ScopedLock(M&...) noexcept {}
+        ~ScopedLock() noexcept = default;
+        ScopedLock(const ScopedLock&) = delete;
+        ScopedLock& operator=(const ScopedLock&) = delete;
+    };
+#endif
+
     // @TODO: Change aliases to switch clock type globally if necessary
 
     // --- CLOCK SELECTION ---
@@ -140,23 +169,31 @@ namespace dmq
     using TimePoint = typename Clock::time_point;
 
     /// @brief Default timeout for the TIMEOUT queue-full policy across all Thread ports.
-    /// Override per-thread at construction or project-wide before including this header.
-    inline constexpr std::chrono::seconds DEFAULT_DISPATCH_TIMEOUT{2};
+    /// Override via DMQ_DEFAULT_DISPATCH_TIMEOUT in DelegateMQConfig.h.
+    inline constexpr std::chrono::seconds DEFAULT_DISPATCH_TIMEOUT{DMQ_DEFAULT_DISPATCH_TIMEOUT};
 
     // --- RESOURCE LIMITS & SBO CONFIGURATION ---
-    
+
     /// @brief Max timers processed in one tick without heap allocation.
-    inline constexpr size_t MAX_TIMER_EXPIRED = 16;
+    /// Override via DMQ_MAX_TIMER_EXPIRED in delegatemqconfig.h.
+    inline constexpr size_t MAX_TIMER_EXPIRED = DMQ_MAX_TIMER_EXPIRED;
 
-    /// @brief Signal Small-Buffer Optimization (SBO) count. 
+    /// @brief Signal Small-Buffer Optimization (SBO) count.
     /// Signals with <= this many subscribers are invoked heap-free.
-    inline constexpr size_t SIGNAL_SBO_COUNT = 8;
+    /// Override via DMQ_SIGNAL_SBO_COUNT in delegatemqconfig.h.
+    inline constexpr size_t SIGNAL_SBO_COUNT = DMQ_SIGNAL_SBO_COUNT;
 
     /// @brief Default internal queue size for all dmq::os::Thread ports.
-    inline constexpr size_t DEFAULT_QUEUE_SIZE = 20;
+    /// Override via DMQ_DEFAULT_QUEUE_SIZE in delegatemqconfig.h.
+    inline constexpr size_t DEFAULT_QUEUE_SIZE = DMQ_DEFAULT_QUEUE_SIZE;
 
     /// @brief Max number of threads that can be monitored by the watchdog.
-    inline constexpr size_t MAX_WATCHDOG_THREADS = 16;
+    /// Override via DMQ_MAX_WATCHDOG_THREADS in delegatemqconfig.h.
+    inline constexpr size_t MAX_WATCHDOG_THREADS = DMQ_MAX_WATCHDOG_THREADS;
+
+    /// @brief Max number of remote Participants the DataBus can hold without heap allocation.
+    /// Override via DMQ_MAX_PARTICIPANTS in delegatemqconfig.h.
+    inline constexpr size_t MAX_PARTICIPANTS = DMQ_MAX_PARTICIPANTS;
 
     // --- MUTEX / LOCK SELECTION ---
 #if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
@@ -241,13 +278,15 @@ namespace dmq
     // Use stl_allocator fixed-block allocator for dynamic storage allocation
     #include "extras/allocator/xstring.h"
     #include "extras/allocator/xlist.h"
+    #include "extras/allocator/xmap.h"
     #include "extras/allocator/xsstream.h"
     #include "extras/allocator/stl_allocator.h"
     #include "extras/allocator/xnew.h"
     #include "extras/allocator/xmake_shared.h"
 #else
     #include <string>
     #include <list>
+    #include <map>
     #include <sstream>
     #include <memory>
     #include <utility>
@@ -288,6 +327,13 @@ namespace dmq
             delete p;
         }
     }
+
+    // Fallback xmap/xmultimap — use std::map when fixed-block allocator is disabled
+    template <typename Key, typename Value, typename Alloc = std::allocator<std::pair<const Key, Value>>>
+    using xmap = std::map<Key, Value, std::less<Key>, Alloc>;
+
+    template <typename Key, typename Value, typename Alloc = std::allocator<std::pair<const Key, Value>>>
+    using xmultimap = std::multimap<Key, Value, std::less<Key>, Alloc>;
 #endif
 
 // @TODO: Select the desired logging (see Port.cmake).
@@ -303,4 +349,4 @@ namespace dmq
     #define LOG_ERROR(...)   do {} while(0)
 #endif
 
-#endif // _DELEGATE_OPT_H
+#endif // _DELEGATE_OPT_H

DelegateMQ/delegate/MulticastDelegateSafe.h

@@ -24,12 +24,12 @@ class MulticastDelegateSafe<RetType(Args...)> : public MulticastDelegate<RetType
     virtual ~MulticastDelegateSafe() = default; 
 
     MulticastDelegateSafe(const MulticastDelegateSafe& rhs) : BaseType() {
-        std::scoped_lock lock(m_lock, rhs.m_lock);
+        dmq::ScopedLock<RecursiveMutex, RecursiveMutex> lock(m_lock, rhs.m_lock);
         BaseType::operator=(rhs);
     }
 
     MulticastDelegateSafe(MulticastDelegateSafe&& rhs) : BaseType() {
-        std::scoped_lock lock(m_lock, rhs.m_lock);
+        dmq::ScopedLock<RecursiveMutex, RecursiveMutex> lock(m_lock, rhs.m_lock);
         BaseType::operator=(std::move(rhs));
     }
 
@@ -124,7 +124,7 @@ class MulticastDelegateSafe<RetType(Args...)> : public MulticastDelegate<RetType
     MulticastDelegateSafe& operator=(const MulticastDelegateSafe& rhs) {
         if (this != &rhs) {
             // Lock both instances safely to prevent modification of source during copy
-            std::scoped_lock lock(m_lock, rhs.m_lock);
+            dmq::ScopedLock<RecursiveMutex, RecursiveMutex> lock(m_lock, rhs.m_lock);
             BaseType::operator=(rhs);
         }
         return *this;
@@ -135,7 +135,7 @@ class MulticastDelegateSafe<RetType(Args...)> : public MulticastDelegate<RetType
     /// @return A reference to the current object.
     MulticastDelegateSafe& operator=(MulticastDelegateSafe&& rhs) noexcept {
         if (this != &rhs) {
-            std::scoped_lock lock(m_lock, rhs.m_lock);
+            dmq::ScopedLock<RecursiveMutex, RecursiveMutex> lock(m_lock, rhs.m_lock);
             BaseType::operator=(std::move(rhs));
         }
         return *this;

DelegateMQ/delegate/UnicastDelegateSafe.h

@@ -89,7 +89,7 @@ class UnicastDelegateSafe<RetType(Args...)> : public UnicastDelegate<RetType(Arg
     /// @return A reference to the current object.
     UnicastDelegateSafe& operator=(const UnicastDelegateSafe& rhs) {
         if (this != &rhs) {
-            std::scoped_lock lock(m_lock, rhs.m_lock);
+            dmq::ScopedLock<RecursiveMutex, RecursiveMutex> lock(m_lock, rhs.m_lock);
             BaseType::operator=(rhs);
         }
         return *this;
@@ -100,7 +100,7 @@ class UnicastDelegateSafe<RetType(Args...)> : public UnicastDelegate<RetType(Arg
     /// @return A reference to the current object.
     UnicastDelegateSafe& operator=(UnicastDelegateSafe&& rhs) noexcept {
         if (this != &rhs) {
-            std::scoped_lock lock(m_lock, rhs.m_lock);
+            dmq::ScopedLock<RecursiveMutex, RecursiveMutex> lock(m_lock, rhs.m_lock);
             BaseType::operator=(std::move(rhs));
         }
         return *this;