Update DelegateMQ library

Author: endurodave

DelegateMQ/External.cmake

@@ -26,8 +26,10 @@ endif()
 if(DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_NNG")
     if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
         set_and_check(NNG_INCLUDE_DIR "${DMQ_ROOT_DIR}/../../../nng/include")
+        set_and_check(NNG_LIBRARY_DIR "${DMQ_ROOT_DIR}/../../../nng/install/lib")
     elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
         set_and_check(NNG_INCLUDE_DIR "/usr/local/include/nng")
+        set_and_check(NNG_LIBRARY_DIR "/usr/local/include/nng")
     endif()
 endif()
 

DelegateMQ/delegate/Delegate.h

@@ -322,25 +322,27 @@ class DelegateMember<TClass, RetType(Args...)> : public Delegate<RetType(Args...
         m_func = reinterpret_cast<MemberFunc>(func);
     }
 
-    /// @brief Bind a member function to the delegate.
-    /// @details This method associates a member function (`func`) with the delegate. 
+    /// @brief Bind a member function to a raw pointer.
+    /// @details Wraps the raw object pointer in a `std::shared_ptr` with a no-op 
+    /// deleter, ensuring the delegate references the object without taking ownership 
+    /// or attempting to delete it. The caller must ensure the object outlives the delegate.
     /// Once the function is bound, the delegate can be used to invoke the function.
-    /// @param[in] object The target object instance.
-    /// @param[in] func The member function to bind to the delegate. This function must 
-    /// match the signature of the delegate.
+    /// @param[in] object The target object instance (raw pointer).
+    /// @param[in] func The const member function to bind.
     void Bind(ObjectPtr object, MemberFunc func) {
         static_assert(!std::is_const<TClass>::value, "Cannot bind non-const function to const object.");
         auto deleter = [](TClass*) {};                        // No-op deleter
         m_object = std::shared_ptr<TClass>(object, deleter);  // Not deleted when out of scope
         m_func = func;
     }
 
-    /// @brief Bind a const member function to the delegate.
-    /// @details This method associates a member function (`func`) with the delegate. 
+    /// @brief Bind a const member function to a raw pointer.
+    /// @details Wraps the raw object pointer in a `std::shared_ptr` with a no-op 
+    /// deleter, ensuring the delegate references the object without taking ownership 
+    /// or attempting to delete it. The caller must ensure the object outlives the delegate.
     /// Once the function is bound, the delegate can be used to invoke the function.
-    /// @param[in] object The target object instance.
-    /// @param[in] func The function to bind to the delegate. The member function to 
-    /// bind to the delegate. This function must match the signature of the delegate.
+    /// @param[in] object The target object instance (raw pointer).
+    /// @param[in] func The const member function to bind.
     void Bind(ObjectPtr object, ConstMemberFunc func) {
         auto deleter = [](TClass*) {};                        // No-op deleter
         m_object = std::shared_ptr<TClass>(object, deleter);  // Not deleted when out of scope

DelegateMQ/delegate/DelegateAsync.h

@@ -42,7 +42,7 @@
 /// * `std::function` compares the function signature type, not the underlying object instance.
 /// See `DelegateFunction<>` class for more info.
 /// 
-/// Code within `<common_code>` and `</common_code>` is updated using sync_src.py. Manually update 
+/// Code within `<common_code>` and `</common_code>` is updated using src_dup.py. Manually update 
 /// the code within the `DelegateFreeAsync` `common_code` tags, then run the script to 
 /// propagate to the remaining delegate classes to simplify code maintenance.
 /// 
@@ -72,6 +72,17 @@ namespace trait
 
     template <typename T>
     struct is_shared_ptr_reference<const std::shared_ptr<T>* > : std::true_type {};
+
+    // Helper trait to check if a type is a double pointer (e.g., int**)
+    template <typename T>
+    struct is_double_pointer {
+        // Remove 'const', 'volatile', and references first
+        using RawT = std::remove_cv_t<std::remove_reference_t<T>>;
+
+        static constexpr bool value =
+            std::is_pointer_v<RawT> &&
+            std::is_pointer_v<std::remove_pointer_t<RawT>>;
+    };
 }
 
 /// @brief Stores all function arguments suitable for non-blocking asynchronous calls.
@@ -153,7 +164,7 @@ class DelegateFreeAsync<RetType(Args...)> : public DelegateFree<RetType(Args...)
     /// @brief Move constructor that transfers ownership of resources.
     /// @param[in] rhs The object to move from.
     DelegateFreeAsync(ClassType&& rhs) noexcept : 
-        BaseType(rhs), m_thread(rhs.m_thread), m_priority(rhs.m_priority) {
+        BaseType(std::move(rhs)), m_thread(rhs.m_thread), m_priority(rhs.m_priority) {
         rhs.Clear();
     }
 
@@ -210,6 +221,7 @@ class DelegateFreeAsync<RetType(Args...)> : public DelegateFree<RetType(Args...)
             BaseType::operator=(std::move(rhs));
             m_thread = rhs.m_thread;    // Use the resource
             m_priority = rhs.m_priority;
+            rhs.Clear();
         }
         return *this;
     }
@@ -427,13 +439,13 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
     /// @brief Move constructor that transfers ownership of resources.
     /// @param[in] rhs The object to move from.
     DelegateMemberAsync(ClassType&& rhs) noexcept :
-        BaseType(rhs), m_thread(rhs.m_thread), m_priority(rhs.m_priority) {
+        BaseType(std::move(rhs)), m_thread(rhs.m_thread), m_priority(rhs.m_priority) {
         rhs.Clear();
     }
 
     DelegateMemberAsync() = default;
 
-    /// @brief Bind a const member function to the delegate.
+    /// @brief Bind a member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -445,7 +457,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
         BaseType::Bind(object, func);
     }
 
-    /// @brief Bind a member function to the delegate.
+    /// @brief Bind a const member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -457,7 +469,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
         BaseType::Bind(object, func);
     }
 
-    /// @brief Bind a const member function to the delegate.
+    /// @brief Bind a member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -469,7 +481,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
         BaseType::Bind(object, func);
     }
 
-    /// @brief Bind a member function to the delegate.
+    /// @brief Bind a const member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -521,6 +533,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
             BaseType::operator=(std::move(rhs));
             m_thread = rhs.m_thread;    // Use the resource
             m_priority = rhs.m_priority;
+            rhs.Clear();
         }
         return *this;
     }
@@ -716,7 +729,7 @@ class DelegateFunctionAsync<RetType(Args...)> : public DelegateFunction<RetType(
     /// @brief Move constructor that transfers ownership of resources.
     /// @param[in] rhs The object to move from.
     DelegateFunctionAsync(ClassType&& rhs) noexcept :
-        BaseType(rhs), m_thread(rhs.m_thread), m_priority(rhs.m_priority) {
+        BaseType(std::move(rhs)), m_thread(rhs.m_thread), m_priority(rhs.m_priority) {
         rhs.Clear();
     }
 
@@ -773,6 +786,7 @@ class DelegateFunctionAsync<RetType(Args...)> : public DelegateFunction<RetType(
             BaseType::operator=(std::move(rhs));
             m_thread = rhs.m_thread;    // Use the resource
             m_priority = rhs.m_priority;
+            rhs.Clear();
         }
         return *this;
     }

DelegateMQ/delegate/DelegateAsyncWait.h

@@ -48,7 +48,7 @@
 /// * `std::function` compares the function signature type, not the underlying object instance.
 /// See `DelegateFunction<>` class for more info.
 ///
-/// Code within `<common_code>` and `</common_code>` is updated using sync_src.py. Manually update 
+/// Code within `<common_code>` and `</common_code>` is updated using src_dup.py. Manually update 
 /// the code within the `DelegateFreeAsyncWait` `common_code` tags, then run the script to 
 /// propagate to the remaining delegate classes to simplify code maintenance.
 /// 
@@ -172,7 +172,7 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
     /// @brief Move constructor that transfers ownership of resources.
     /// @param[in] rhs The object to move from.
     DelegateFreeAsyncWait(ClassType&& rhs) noexcept :
-        BaseType(rhs), m_thread(rhs.m_thread), m_priority(rhs.m_priority), m_timeout(rhs.m_timeout), m_success(rhs.m_success), m_retVal(rhs.m_retVal) {
+        BaseType(std::move(rhs)), m_thread(rhs.m_thread), m_priority(rhs.m_priority), m_timeout(rhs.m_timeout), m_success(rhs.m_success), m_retVal(rhs.m_retVal) {
         rhs.Clear();
     }
 
@@ -302,7 +302,7 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
     /// Use `IsSuccess()` to check for success before using the return value. Alternatively, 
     /// use `AsyncInvoke()` and check the `std::optional` return value.
     /// 
-    /// The `DelegateAsyncWaitMsg` does not duplicated and copy the function arguments into heap
+    /// The `DelegateAsyncWaitMsg` does not duplicate and copy the function arguments into heap
     /// memory. The source thread waits on the destintation thread to complete, therefore argument
     /// data is shared between the source and destination threads and simultaneous access is prevented
     /// using a mutex.
@@ -338,8 +338,12 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
                 thread->DispatchDelegate(msg);
 
                 // Wait for destination thread to execute the delegate function and get return value
-                if ((m_success = msg->GetSema().Wait(m_timeout)))
+                if (msg->GetSema().Wait(m_timeout)) {
+                    // Wait succeeded. Now acquire lock to safely read the value.
+                    const std::lock_guard<std::mutex> lock(msg->GetLock());
+                    m_success = true;
                     m_retVal = delegate->m_retVal;
+                }
             }
 
             // Protect data shared between source and destination threads
@@ -542,13 +546,13 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
     /// @brief Move constructor that transfers ownership of resources.
     /// @param[in] rhs The object to move from.
     DelegateMemberAsyncWait(ClassType&& rhs) noexcept :
-        BaseType(rhs), m_thread(rhs.m_thread), m_priority(rhs.m_priority), m_timeout(rhs.m_timeout), m_success(rhs.m_success), m_retVal(rhs.m_retVal) {
+        BaseType(std::move(rhs)), m_thread(rhs.m_thread), m_priority(rhs.m_priority), m_timeout(rhs.m_timeout), m_success(rhs.m_success), m_retVal(rhs.m_retVal) {
         rhs.Clear();
     }
 
     DelegateMemberAsyncWait() = default;
 
-    /// @brief Bind a const member function to the delegate.
+    /// @brief Bind a member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -563,7 +567,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
         BaseType::Bind(object, func);
     }
 
-    /// @brief Bind a member function to the delegate.
+    /// @brief Bind a const member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -578,7 +582,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
         BaseType::Bind(object, func);
     }
 
-    /// @brief Bind a const member function to the delegate.
+    /// @brief Bind a member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -593,7 +597,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
         BaseType::Bind(object, func);
     }
 
-    /// @brief Bind a member function to the delegate.
+    /// @brief Bind a const member function to the delegate.
     /// @details This method associates a member function (`func`) with the delegate. 
     /// Once the function is bound, the delegate can be used to invoke the function.
     /// @param[in] object The target object instance.
@@ -718,7 +722,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
     /// Use `IsSuccess()` to check for success before using the return value. Alternatively, 
     /// use `AsyncInvoke()` and check the `std::optional` return value.
     /// 
-    /// The `DelegateAsyncWaitMsg` does not duplicated and copy the function arguments into heap
+    /// The `DelegateAsyncWaitMsg` does not duplicate and copy the function arguments into heap
     /// memory. The source thread waits on the destintation thread to complete, therefore argument
     /// data is shared between the source and destination threads and simultaneous access is prevented
     /// using a mutex.
@@ -754,8 +758,12 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
                 thread->DispatchDelegate(msg);
 
                 // Wait for destination thread to execute the delegate function and get return value
-                if ((m_success = msg->GetSema().Wait(m_timeout)))
+                if (msg->GetSema().Wait(m_timeout)) {
+                    // Wait succeeded. Now acquire lock to safely read the value.
+                    const std::lock_guard<std::mutex> lock(msg->GetLock());
+                    m_success = true;
                     m_retVal = delegate->m_retVal;
+                }
             }
 
             // Protect data shared between source and destination threads
@@ -923,7 +931,7 @@ class DelegateFunctionAsyncWait<RetType(Args...)> : public DelegateFunction<RetT
     /// @brief Move constructor that transfers ownership of resources.
     /// @param[in] rhs The object to move from.
     DelegateFunctionAsyncWait(ClassType&& rhs) noexcept :
-        BaseType(rhs), m_thread(rhs.m_thread), m_priority(rhs.m_priority), m_timeout(rhs.m_timeout), m_success(rhs.m_success), m_retVal(rhs.m_retVal) {
+        BaseType(std::move(rhs)), m_thread(rhs.m_thread), m_priority(rhs.m_priority), m_timeout(rhs.m_timeout), m_success(rhs.m_success), m_retVal(rhs.m_retVal) {
         rhs.Clear();
     }
 
@@ -1053,7 +1061,7 @@ class DelegateFunctionAsyncWait<RetType(Args...)> : public DelegateFunction<RetT
     /// Use `IsSuccess()` to check for success before using the return value. Alternatively, 
     /// use `AsyncInvoke()` and check the `std::optional` return value.
     /// 
-    /// The `DelegateAsyncWaitMsg` does not duplicated and copy the function arguments into heap
+    /// The `DelegateAsyncWaitMsg` does not duplicate and copy the function arguments into heap
     /// memory. The source thread waits on the destintation thread to complete, therefore argument
     /// data is shared between the source and destination threads and simultaneous access is prevented
     /// using a mutex.
@@ -1089,8 +1097,12 @@ class DelegateFunctionAsyncWait<RetType(Args...)> : public DelegateFunction<RetT
                 thread->DispatchDelegate(msg);
 
                 // Wait for destination thread to execute the delegate function and get return value
-                if ((m_success = msg->GetSema().Wait(m_timeout)))
+                if (msg->GetSema().Wait(m_timeout)) {
+                    // Wait succeeded. Now acquire lock to safely read the value.
+                    const std::lock_guard<std::mutex> lock(msg->GetLock());
+                    m_success = true;
                     m_retVal = delegate->m_retVal;
+                }
             }
 
             // Protect data shared between source and destination threads