Update DelegateMQ library

Author: endurodave

DelegateMQ/delegate/DelegateAsync.h

@@ -267,7 +267,7 @@ class DelegateFreeAsync<RetType(Args...)> : public DelegateFree<RetType(Args...)
         }
         else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 
@@ -580,7 +580,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
         }
         else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 
@@ -822,7 +822,7 @@ class DelegateMemberAsyncSp<TClass, RetType(Args...)> : public DelegateMemberSp<
         }
         else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 
@@ -1076,7 +1076,7 @@ class DelegateFunctionAsync<RetType(Args...)> : public DelegateFunction<RetType(
         }
         else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 

DelegateMQ/delegate/DelegateAsyncWait.h

@@ -325,7 +325,7 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
             return BaseType::operator()(std::forward<Args>(args)...);
         } else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 
@@ -761,7 +761,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
             return BaseType::operator()(std::forward<Args>(args)...);
         } else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 
@@ -1114,7 +1114,7 @@ class DelegateMemberAsyncWaitSp<TClass, RetType(Args...)> : public DelegateMembe
             return BaseType::operator()(std::forward<Args>(args)...);
         } else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 
@@ -1469,7 +1469,7 @@ class DelegateFunctionAsyncWait<RetType(Args...)> : public DelegateFunction<RetT
             return BaseType::operator()(std::forward<Args>(args)...);
         } else {
             // Create a clone instance of this delegate 
-            auto delegate = std::shared_ptr<ClassType>(Clone());
+            auto delegate = xmake_shared<ClassType>(*this);
             if (!delegate)
                 BAD_ALLOC();
 

DelegateMQ/delegate/DelegateOpt.h

@@ -139,6 +139,7 @@ namespace dmq
     #include "predef/allocator/xlist.h"
     #include "predef/allocator/xsstream.h"
     #include "predef/allocator/stl_allocator.h"
+    #include "predef/allocator/xnew.h"
 #else
     #include <string>
     #include <list>
@@ -170,6 +171,17 @@ namespace dmq
     {
         return std::make_shared<T>(std::forward<Args>(args)...);
     }
+
+    // Fallback xnew/xdelete — use standard new/delete when fixed-block allocator is disabled
+    template<typename T, typename... Args>
+    inline T* xnew(Args&&... args) {
+        return new(std::nothrow) T(std::forward<Args>(args)...);
+    }
+
+    template<typename T>
+    inline void xdelete(T* p) {
+        delete p;
+    }
 #endif
 
 // @TODO: Select the desired logging (see Predef.cmake).

DelegateMQ/delegate/make_tuple_heap.h

@@ -68,8 +68,8 @@ class heap_arg_deleter : public heap_arg_deleter_base
 {
 public:
     heap_arg_deleter(T& arg) : m_arg(arg) { }
-    virtual ~heap_arg_deleter() { 
-        delete &m_arg; 
+    virtual ~heap_arg_deleter() {
+        xdelete(&m_arg);
     }
 private:
     T& m_arg;
@@ -81,8 +81,8 @@ class heap_arg_deleter<T*> : public heap_arg_deleter_base
 {
 public:
     heap_arg_deleter(T* arg) : m_arg(arg) { }
-    virtual ~heap_arg_deleter() { 
-        delete m_arg; 
+    virtual ~heap_arg_deleter() {
+        xdelete(m_arg);
     }
 private:
     T* m_arg;
@@ -93,13 +93,17 @@ template<typename T>
 class heap_arg_deleter<T**> : public heap_arg_deleter_base
 {
 public:
-    heap_arg_deleter(T** arg) : m_arg(arg) {}
+    // Capture the original inner pointer at construction so the destructor always
+    // frees the xnew'd copy, regardless of whether the target function overwrites
+    // *arg (e.g. an outgoing-argument pattern like (*s) = new T).
+    heap_arg_deleter(T** arg) : m_arg(arg), m_inner(*arg) {}
     virtual ~heap_arg_deleter() {
-        delete *m_arg;
-        delete m_arg;
+        xdelete(m_inner);   // free the original xnew'd inner copy (may be nullptr)
+        xdelete(m_arg);     // free the outer pointer storage
     }
 private:
     T** m_arg;
+    T*  m_inner;  // original value of *arg at dispatch time
 };
 
 /// @brief Append a pointer to pointer argument to the tuple
@@ -111,28 +115,28 @@ auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const
     // Check if arg is nullptr or *arg is nullptr
     if (arg != nullptr && *arg != nullptr) {
         // Allocate memory for heap_arg and copy the value
-        heap_arg = new(std::nothrow) Arg * ();
+        heap_arg = xnew<Arg*>();
         if (!heap_arg) {
             BAD_ALLOC();
         }
-            
-        *heap_arg = new(std::nothrow) Arg(**arg);
+
+        *heap_arg = xnew<Arg>(**arg);
         if (!*heap_arg) {
-            delete heap_arg;
+            xdelete(heap_arg);
             BAD_ALLOC();
         }
     }
     else {
         // If arg is nullptr or *arg is nullptr, create heap_arg as nullptr
-        heap_arg = new(std::nothrow) Arg * (nullptr);
+        heap_arg = xnew<Arg*>(nullptr);
         if (!heap_arg) {
             BAD_ALLOC();
         }
     }
-    std::shared_ptr<heap_arg_deleter_base> deleter(new(std::nothrow) heap_arg_deleter<Arg**>(heap_arg));
+    auto deleter = xmake_shared<heap_arg_deleter<Arg**>>(heap_arg);
     if (!deleter) {
-        delete* heap_arg;
-        delete heap_arg;
+        xdelete(*heap_arg);
+        xdelete(heap_arg);
         BAD_ALLOC();
     }
 
@@ -157,14 +161,14 @@ auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const
 {
     Arg* heap_arg = nullptr;
     if (arg != nullptr) {
-        heap_arg = new(std::nothrow) Arg(*arg);  // Only create a new Arg if arg is not nullptr
+        heap_arg = xnew<Arg>(*arg);
         if (!heap_arg) {
             BAD_ALLOC();
         }
     }
-    std::shared_ptr<heap_arg_deleter_base> deleter(new(std::nothrow) heap_arg_deleter<Arg*>(heap_arg));
+    auto deleter = xmake_shared<heap_arg_deleter<Arg*>>(heap_arg);
     if (!deleter) {
-        delete heap_arg;
+        xdelete(heap_arg);
         BAD_ALLOC();
     }
 
@@ -187,13 +191,13 @@ auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const
 template <typename Arg, typename... TupleElem>
 auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const std::tuple<TupleElem...> &tup, Arg& arg)
 {
-    Arg* heap_arg = new(std::nothrow) Arg(arg);
+    Arg* heap_arg = xnew<Arg>(arg);
     if (!heap_arg) {
         BAD_ALLOC();
     }
-    std::shared_ptr<heap_arg_deleter_base> deleter(new(std::nothrow) heap_arg_deleter<Arg*>(heap_arg));
+    auto deleter = xmake_shared<heap_arg_deleter<Arg*>>(heap_arg);
     if (!deleter) {
-        delete heap_arg;
+        xdelete(heap_arg);
         BAD_ALLOC();
     }
 

DelegateMQ/predef/allocator/xnew.h

@@ -0,0 +1,42 @@
+#ifndef _XNEW_H
+#define _XNEW_H
+
+// @see https://github.com/endurodave/DelegateMQ
+// David Lafreniere, 2026.
+
+/// @file xnew.h
+/// @brief Fixed-block pool equivalents of operator new / delete.
+///
+/// @details
+/// xnew<T>(args...) allocates from the xallocator fixed-block pool and
+/// constructs T in-place via placement new. xdelete<T>(p) calls the
+/// destructor then returns the memory to the pool via xfree().
+///
+/// These are the pool-aware counterparts of new(std::nothrow) / delete
+/// for types that do not carry the XALLOCATOR macro (e.g. user argument
+/// types marshalled through make_tuple_heap).
+
+#include "xallocator.h"
+
+/// @brief Allocate and construct T in the fixed-block pool.
+/// @return Pointer to the constructed object, or nullptr if xmalloc fails.
+template<typename T, typename... Args>
+inline T* xnew(Args&&... args)
+{
+    void* mem = xmalloc(sizeof(T));
+    if (!mem) return nullptr;
+    return ::new(mem) T(std::forward<Args>(args)...);
+}
+
+/// @brief Destroy T and return its memory to the fixed-block pool.
+template<typename T>
+inline void xdelete(T* p)
+{
+    if (p)
+    {
+        p->~T();
+        xfree(const_cast<void*>(static_cast<const void*>(p)));
+    }
+}
+
+#endif // _XNEW_H

DelegateMQ/predef/os/stdlib/Thread.cpp

@@ -16,7 +16,7 @@ using namespace dmq;
 // Thread
 //----------------------------------------------------------------------------
 Thread::Thread(const std::string& threadName, size_t maxQueueSize)
-    : m_thread(nullptr)
+    : m_thread(std::nullopt)
     , m_exit(false)
     , THREAD_NAME(threadName)
     , MAX_QUEUE_SIZE(maxQueueSize)
@@ -38,17 +38,17 @@ bool Thread::CreateThread(std::optional<dmq::Duration> watchdogTimeout)
 {
     if (!m_thread)
     {
-        m_threadStartPromise = std::promise<void>();
-        m_threadStartFuture = m_threadStartPromise.get_future();
+        m_threadStartPromise.emplace();
+        m_threadStartFuture.emplace(m_threadStartPromise->get_future());
         m_exit = false;
 
-        m_thread = std::unique_ptr<std::thread>(new thread(&Thread::Process, this));
+        m_thread.emplace(&Thread::Process, this);
 
         auto handle = m_thread->native_handle();
         SetThreadName(handle, THREAD_NAME);
 
         // Wait for the thread to enter the Process method
-        m_threadStartFuture.get();
+        m_threadStartFuture->get();
 
         m_lastAliveTime.store(Timer::GetNow());
 
@@ -59,12 +59,12 @@ bool Thread::CreateThread(std::optional<dmq::Duration> watchdogTimeout)
             m_watchdogTimeout = watchdogTimeout.value();
 
             // Timer to ensure the Thread instance runs periodically.
-            m_threadTimer = std::make_unique<Timer>();
+            m_threadTimer = std::unique_ptr<Timer>(new Timer());
             m_threadTimerConn = m_threadTimer->OnExpired.Connect(MakeDelegate(this, &Thread::ThreadCheck, *this));
             m_threadTimer->Start(m_watchdogTimeout.load() / 4);
 
             // Timer to check that this Thread instance runs. 
-            m_watchdogTimer = std::make_unique<Timer>();
+            m_watchdogTimer = std::unique_ptr<Timer>(new Timer());
             m_watchdogTimerConn = m_watchdogTimer->OnExpired.Connect(MakeDelegate(this, &Thread::WatchdogCheck));
             m_watchdogTimer->Start(m_watchdogTimeout.load() / 2);
         }
@@ -79,7 +79,7 @@ bool Thread::CreateThread(std::optional<dmq::Duration> watchdogTimeout)
 //----------------------------------------------------------------------------
 std::thread::id Thread::GetThreadId()
 {
-    if (m_thread == nullptr)
+    if (!m_thread.has_value())
         throw std::invalid_argument("Thread pointer is null");
 
     return m_thread->get_id();
@@ -147,7 +147,7 @@ void Thread::ExitThread()
     }
 
     // Create a new ThreadMsg
-    std::shared_ptr<ThreadMsg> threadMsg(new ThreadMsg(MSG_EXIT_THREAD, 0));
+    auto threadMsg = xmake_shared<ThreadMsg>(MSG_EXIT_THREAD, nullptr);
 
     {
         lock_guard<mutex> lock(m_mutex);
@@ -182,7 +182,7 @@ void Thread::ExitThread()
 
     {
         lock_guard<mutex> lock(m_mutex);
-        m_thread = nullptr;
+        m_thread.reset();
         while (!m_queue.empty())
             m_queue.pop();
 
@@ -202,11 +202,11 @@ void Thread::DispatchDelegate(std::shared_ptr<dmq::DelegateMsg> msg)
     if (m_exit.load())
         return;
 
-    if (m_thread == nullptr)
+    if (!m_thread.has_value())
         throw std::invalid_argument("Thread pointer is null");
 
     // If using XALLOCATOR explicit operator new required. See xallocator.h.
-    std::shared_ptr<ThreadMsg> threadMsg(new ThreadMsg(MSG_DISPATCH_DELEGATE, msg));
+    auto threadMsg = xmake_shared<ThreadMsg>(MSG_DISPATCH_DELEGATE, msg);
 
     std::unique_lock<std::mutex> lk(m_mutex);
 
@@ -264,7 +264,7 @@ void Thread::ThreadCheck()
 void Thread::Process()
 {
     // Signal that the thread has started processing to notify CreateThread
-    m_threadStartPromise.set_value();
+    m_threadStartPromise->set_value();
 
     LOG_INFO("Thread::Process Start {}", THREAD_NAME);
 

DelegateMQ/predef/os/stdlib/Thread.h

@@ -107,10 +107,16 @@ class Thread : public dmq::IThread
     /// other user delegate events to be handled.
     void ThreadCheck();
 
-    std::unique_ptr<std::thread> m_thread;
+    std::optional<std::thread> m_thread;
+#ifdef DMQ_ALLOCATOR
+    std::priority_queue<std::shared_ptr<ThreadMsg>,
+        std::vector<std::shared_ptr<ThreadMsg>, stl_allocator<std::shared_ptr<ThreadMsg>>>,
+        ThreadMsgComparator> m_queue;
+#else
     std::priority_queue<std::shared_ptr<ThreadMsg>,
         std::vector<std::shared_ptr<ThreadMsg>>,
         ThreadMsgComparator> m_queue;
+#endif
     std::mutex m_mutex;
     std::condition_variable m_cv;
 
@@ -122,9 +128,9 @@ class Thread : public dmq::IThread
     // Max queue size for back pressure (0 = unlimited)
     const size_t MAX_QUEUE_SIZE;
 
-    // Promise and future to synchronize thread start
-    std::promise<void> m_threadStartPromise;
-    std::future<void> m_threadStartFuture;
+    // Promise and future to synchronize thread start (constructed lazily in CreateThread)
+    std::optional<std::promise<void>> m_threadStartPromise;
+    std::optional<std::future<void>> m_threadStartFuture;
 
     std::atomic<bool> m_exit;
 

DelegateMQ/predef/os/win32/Thread.cpp

@@ -60,12 +60,12 @@ bool Thread::CreateThread(std::optional<dmq::Duration> watchdogTimeout)
             m_watchdogTimeout = watchdogTimeout.value();
 
             // Timer to ensure the Thread instance runs periodically.
-            m_threadTimer = std::make_unique<Timer>();
+            m_threadTimer = std::unique_ptr<Timer>(new Timer());
             m_threadTimerConn = m_threadTimer->OnExpired.Connect(MakeDelegate(this, &Thread::ThreadCheck, *this));
             m_threadTimer->Start(m_watchdogTimeout.load() / 4);
 
             // Timer to check that this Thread instance runs.
-            m_watchdogTimer = std::make_unique<Timer>();
+            m_watchdogTimer = std::unique_ptr<Timer>(new Timer());
             m_watchdogTimerConn = m_watchdogTimer->OnExpired.Connect(MakeDelegate(this, &Thread::WatchdogCheck));
             m_watchdogTimer->Start(m_watchdogTimeout.load() / 2);
         }