Update DelegateMQ library

Author: endurodave

DelegateMQ/Predef.cmake

@@ -32,9 +32,15 @@ elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_ZEPHYR")
     )
 elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_CMSIS_RTOS2")
     add_compile_definitions(DMQ_THREAD_CMSIS_RTOS2)
-    file(GLOB THREAD_SOURCES 
-        "${DMQ_ROOT_DIR}/predef/os/cmsis-rtos2/*.c*" 
-        "${DMQ_ROOT_DIR}/predef/os/cmsis-rtos2/*.h" 
+    file(GLOB THREAD_SOURCES
+        "${DMQ_ROOT_DIR}/predef/os/cmsis-rtos2/*.c*"
+        "${DMQ_ROOT_DIR}/predef/os/cmsis-rtos2/*.h"
+    )
+elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_QT")
+    add_compile_definitions(DMQ_THREAD_QT)
+    file(GLOB THREAD_SOURCES
+        "${DMQ_ROOT_DIR}/predef/os/qt/*.c*"
+        "${DMQ_ROOT_DIR}/predef/os/qt/*.h"
     )
 elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_NONE")
     add_compile_definitions(DMQ_THREAD_NONE)
@@ -100,7 +106,7 @@ elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_ARM_LWIP_NETCONN_UDP")
     file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/arm-lwip-netconn-udp/*.h")    
 elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_THREADX_UDP")
     add_compile_definitions(DMQ_TRANSPORT_THREADX_UDP)
-    file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/threadx-udp/*.h")
+    file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/netx-udp/*.h")
 elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_STM32_UART")
     add_compile_definitions(DMQ_TRANSPORT_STM32_UART)
     file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/stm32-uart/*.h")

DelegateMQ/delegate/DelegateAsync.h

@@ -272,8 +272,7 @@ class DelegateFreeAsync<RetType(Args...)> : public DelegateFree<RetType(Args...)
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncMsg<Args...>> msg(new DelegateAsyncMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
 
@@ -586,8 +585,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncMsg<Args...>> msg(new DelegateAsyncMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
 
@@ -829,8 +827,7 @@ class DelegateMemberAsyncSp<TClass, RetType(Args...)> : public DelegateMemberSp<
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncMsg<Args...>> msg(new DelegateAsyncMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
 
@@ -1084,8 +1081,7 @@ class DelegateFunctionAsync<RetType(Args...)> : public DelegateFunction<RetType(
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncMsg<Args...>> msg(new DelegateAsyncMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
 

DelegateMQ/delegate/DelegateAsyncWait.h

@@ -330,8 +330,7 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread.
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncWaitMsg<Args...>> msg(new DelegateAsyncWaitMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncWaitMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
             msg->SetInvokerWaiting(true);
@@ -767,8 +766,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread.
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncWaitMsg<Args...>> msg(new DelegateAsyncWaitMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncWaitMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
             msg->SetInvokerWaiting(true);
@@ -1121,8 +1119,7 @@ class DelegateMemberAsyncWaitSp<TClass, RetType(Args...)> : public DelegateMembe
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread.
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncWaitMsg<Args...>> msg(new DelegateAsyncWaitMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncWaitMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
             msg->SetInvokerWaiting(true);
@@ -1477,8 +1474,7 @@ class DelegateFunctionAsyncWait<RetType(Args...)> : public DelegateFunction<RetT
                 BAD_ALLOC();
 
             // Create a new message instance for sending to the destination thread.
-            // If using XALLOCATOR explicit operator new required. See xallocator.h.
-            std::shared_ptr<DelegateAsyncWaitMsg<Args...>> msg(new DelegateAsyncWaitMsg<Args...>(delegate, m_priority, std::forward<Args>(args)...));
+            auto msg = xmake_shared<DelegateAsyncWaitMsg<Args...>>(delegate, m_priority, std::forward<Args>(args)...);
             if (!msg)
                 BAD_ALLOC();
             msg->SetInvokerWaiting(true);

DelegateMQ/delegate/DelegateMsg.h

@@ -42,7 +42,7 @@ class DelegateMsg
 
 	/// Get the delegate message priority
 	/// @return Delegate message priority
-	Priority GetPriority() { return m_priority; }
+	Priority GetPriority() const { return m_priority; }
 
 private:
 	/// The IThreadInvoker instance used to invoke the target function 

DelegateMQ/delegate/DelegateOpt.h

@@ -12,9 +12,9 @@
     #error "RTTI compiler option is disabled but required by the DelegateMQ library."
 #endif
 
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32)
-    // Windows / Linux / macOS (Standard Library)
-    #include <condition_variable> 
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
+    // Windows / Linux / macOS / Qt (Standard Library)
+    #include <condition_variable>
 #elif defined(DMQ_THREAD_FREERTOS)
     #include "predef/util/FreeRTOSClock.h"
     #include "predef/util/FreeRTOSMutex.h"
@@ -38,7 +38,7 @@ namespace dmq
     // @TODO: Change aliases to switch clock type globally if necessary
 
     // --- CLOCK SELECTION ---
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32)
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
     // Windows / Linux / macOS / Qt
     using Clock = std::chrono::steady_clock;
 
@@ -68,7 +68,7 @@ namespace dmq
     using TimePoint = typename Clock::time_point;
 
     // --- MUTEX / LOCK SELECTION ---
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32)
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
     // Windows / Linux / macOS / Qt
     using Mutex = std::mutex;
     using RecursiveMutex = std::recursive_mutex;
@@ -143,6 +143,8 @@ namespace dmq
     #include <string>
     #include <list>
     #include <sstream>
+    #include <memory>
+    #include <utility>
 
     // Not using xallocator; define as nothing
     #undef XALLOCATOR
@@ -161,6 +163,13 @@ namespace dmq
 
     typedef std::string xstring;
     typedef std::wstring xwstring;
+
+    // Fallback xmake_shared — uses std::make_shared when fixed-block allocator is disabled
+    template <typename T, typename... Args>
+    inline std::shared_ptr<T> xmake_shared(Args&&... args)
+    {
+        return std::make_shared<T>(std::forward<Args>(args)...);
+    }
 #endif
 
 // @TODO: Select the desired logging (see Predef.cmake).

DelegateMQ/delegate/IThread.h

@@ -25,17 +25,21 @@ class IThread
 	virtual ~IThread() = default;
 
 	/// @brief Enqueues a delegate message for execution on this thread.
-	/// 
-	/// @details 
-	/// This function is called by the *source* thread (the caller). The implementation must 
+	///
+	/// @details
+	/// This function is called by the *source* thread (the caller). The implementation must
 	/// thread-safely transfer ownership of the `msg` into the target thread's processing queue.
-	/// 
-	/// Once the message is received by the target thread's main loop, that loop is responsible 
+	///
+	/// Once the message is received by the target thread's main loop, that loop is responsible
 	/// for calling `IInvoker::Invoke(msg)` to actually execute the function.
 	///
-	/// @param[in] msg A shared pointer to the delegate message. This pointer must remain valid 
+	/// @param[in] msg A shared pointer to the delegate message. This pointer must remain valid
 	/// until the target thread finishes execution.
 	virtual void DispatchDelegate(std::shared_ptr<DelegateMsg> msg) = 0;
+
+	/// @brief Returns true if the calling thread is this thread.
+	/// Used to decide whether to marshal an event or execute inline.
+	virtual bool IsCurrentThread() = 0;
 };
 
 }

DelegateMQ/delegate/Signal.h

@@ -165,6 +165,8 @@ class Signal<RetType(Args...)>
     ///         or call `Disconnect()` manually.
     [[nodiscard]] ScopedConnection Connect(const DelegateType& delegate) {
         auto copy  = std::shared_ptr<DelegateType>(delegate.Clone());
+        if (!copy)
+            BAD_ALLOC();
         auto state = m_state;
         {
             std::lock_guard<RecursiveMutex> lock(state->mtx);
@@ -216,7 +218,7 @@ class Signal<RetType(Args...)>
         xlist<std::shared_ptr<DelegateType>> delegates;
         XALLOCATOR
     };
-    std::shared_ptr<State> m_state = std::make_shared<State>();
+    std::shared_ptr<State> m_state = xmake_shared<State>();
 };
 
 } // namespace dmq

DelegateMQ/predef/allocator/stl_allocator.h

@@ -5,7 +5,8 @@
 // David Lafreniere
 
 #include "xallocator.h"
-#include <memory>  // For std::allocator and std::allocator_traits
+#include <memory>    // For std::allocator and std::allocator_traits
+#include <utility>   // For std::forward
 
 // Forward declaration for stl_allocator<void>
 template <typename T>
@@ -63,9 +64,16 @@ class stl_allocator : public std::allocator<T>
 
 // Comparison operators for compatibility
 template <typename T, typename U>
-inline bool operator==(const stl_allocator<T>&, const stl_allocator<U>) { return true; }
+inline bool operator==(const stl_allocator<T>&, const stl_allocator<U>&) { return true; }
 
 template <typename T, typename U>
-inline bool operator!=(const stl_allocator<T>&, const stl_allocator<U>) { return false; }
+inline bool operator!=(const stl_allocator<T>&, const stl_allocator<U>&) { return false; }
+
+// Create a shared_ptr with both the object and control block allocated from the fixed-block pool
+template <typename T, typename... Args>
+inline std::shared_ptr<T> xmake_shared(Args&&... args)
+{
+    return std::allocate_shared<T>(stl_allocator<T>(), std::forward<Args>(args)...);
+}
 
 #endif 

DelegateMQ/predef/os/cmsis-rtos2/Thread.cpp

@@ -142,6 +142,14 @@ osThreadId_t Thread::GetCurrentThreadId()
     return osThreadGetId();
 }
 
+//----------------------------------------------------------------------------
+// IsCurrentThread
+//----------------------------------------------------------------------------
+bool Thread::IsCurrentThread()
+{
+    return GetThreadId() == GetCurrentThreadId();
+}
+
 //----------------------------------------------------------------------------
 // DispatchDelegate
 //----------------------------------------------------------------------------

DelegateMQ/predef/os/cmsis-rtos2/Thread.h

@@ -48,6 +48,9 @@ class Thread : public dmq::IThread
     osThreadId_t GetThreadId();
     static osThreadId_t GetCurrentThreadId();
 
+    /// Returns true if the calling thread is this thread
+    virtual bool IsCurrentThread() override;
+
     /// Set the thread priority.
     /// Can be called before or after CreateThread().
     void SetThreadPriority(osPriority_t priority);