Update DelegateMQ library

Author: endurodave

CMakeLists.txt

@@ -14,8 +14,8 @@ set(DMQ_ALLOCATOR "OFF")                      # ON for fixed-block allocator
 set(DMQ_LOG "OFF")                            # ON for spglog output
 set(DMQ_UTIL "ON")                            # ON for delegate utility classes
 set(DMQ_THREAD "DMQ_THREAD_STDLIB")           # Set thread support library or none
-set(DMQ_SERIALIZE "DMQ_SERIALIZE_NONE")       # Set serialization support library or none
-set(DMQ_TRANSPORT "DMQ_TRANSPORT_NONE")       # Set transport support library or none
+set(DMQ_SERIALIZE "DMQ_SERIALIZE_SERIALIZE")  # Set serialization support library or none
+set(DMQ_TRANSPORT "DMQ_TRANSPORT_WIN32_UDP")  # Set transport support library or none           TODO: Linux or Windows
 include("${CMAKE_SOURCE_DIR}/DelegateMQ/DelegateMQ.cmake")
 
 # Enable integration test build

DelegateMQ/DelegateMQ.h

@@ -69,7 +69,14 @@
 // - FreeRTOS: Uses FreeRTOSRecursiveMutex
 // - Bare Metal: Uses NullMutex
 // - StdLib: Uses std::recursive_mutex
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_NONE)
+// Valid for any platform where a Mutex is defined in DelegateOpt.h
+#if defined(DMQ_THREAD_STDLIB) || \
+    defined(DMQ_THREAD_FREERTOS) || \
+    defined(DMQ_THREAD_THREADX) || \
+    defined(DMQ_THREAD_ZEPHYR) || \
+    defined(DMQ_THREAD_CMSIS_RTOS2) || \
+    defined(DMQ_THREAD_QT) || \
+    defined(DMQ_THREAD_NONE)
     #include "delegate/MulticastDelegateSafe.h"
     #include "delegate/UnicastDelegateSafe.h"
     #include "delegate/SignalSafe.h"
@@ -81,17 +88,24 @@
 // - FreeRTOS: OK 
 // - Bare Metal: OK (Requires you to implement IThread wrapper for Event Loop)
 // - StdLib: OK
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_NONE)
+// Valid for any platform that implements the IThread interface
+#if defined(DMQ_THREAD_STDLIB) || \
+    defined(DMQ_THREAD_FREERTOS) || \
+    defined(DMQ_THREAD_THREADX) || \
+    defined(DMQ_THREAD_ZEPHYR) || \
+    defined(DMQ_THREAD_CMSIS_RTOS2) || \
+    defined(DMQ_THREAD_QT) || \
+    defined(DMQ_THREAD_NONE)
     #include "delegate/DelegateAsync.h"
 #endif
 
 // -----------------------------------------------------------------------------
 // 4. Asynchronous "Blocking" Delegates (Wait for Result)
 // -----------------------------------------------------------------------------
-// - FreeRTOS: NO (Requires Semaphore/Condition Variable)
-// - Bare Metal: NO (Cannot block/sleep)
-// - StdLib: OK
-#if defined(DMQ_THREAD_STDLIB)
+// Depends on std::future/std::promise. 
+// Valid for StdLib (Windows/Linux) and Qt.
+// (RTOS support depends on if the toolchain provides a full C++ STL)
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_QT)
     #include "delegate/DelegateAsyncWait.h"
 #endif
 
@@ -101,6 +115,18 @@
 #elif defined(DMQ_THREAD_FREERTOS)
     #include "predef/os/freertos/Thread.h"
     #include "predef/os/freertos/ThreadMsg.h"
+#elif defined(DMQ_THREAD_THREADX)
+    #include "predef/os/threadx/Thread.h"
+    #include "predef/os/threadx/ThreadMsg.h"
+#elif defined(DMQ_THREAD_ZEPHYR)
+    #include "predef/os/zephyr/Thread.h"
+    #include "predef/os/zephyr/ThreadMsg.h"
+#elif defined(DMQ_THREAD_CMSIS_RTOS2)
+    #include "predef/os/cmsis-rtos2/Thread.h"
+    #include "predef/os/cmsis-rtos2/ThreadMsg.h"
+#elif defined(DMQ_THREAD_QT)
+    #include "predef/os/qt/Thread.h"
+    #include "predef/os/qt/ThreadMsg.h"
 #elif defined(DMQ_THREAD_NONE)
     // Bare metal: User must implement their own polling/interrupt logic
 #else
@@ -135,12 +161,24 @@
 #elif defined(DMQ_TRANSPORT_WIN32_UDP)
     #include "predef/dispatcher/Dispatcher.h"
     #include "predef/transport/win32-udp/Win32UdpTransport.h"
+#elif defined(DMQ_TRANSPORT_WIN32_TCP)
+    #include "predef/dispatcher/Dispatcher.h"
+    #include "predef/transport/win32-tcp/Win32TcpTransport.h"
 #elif defined(DMQ_TRANSPORT_LINUX_UDP)
     #include "predef/dispatcher/Dispatcher.h"
     #include "predef/transport/linux-udp/LinuxUdpTransport.h"
+#elif defined(DMQ_TRANSPORT_LINUX_TCP)
+    #include "predef/dispatcher/Dispatcher.h"
+    #include "predef/transport/linux-tcp/LinuxTcpTransport.h"
 #elif defined(DMQ_TRANSPORT_MQTT)
     #include "predef/dispatcher/Dispatcher.h"
     #include "predef/transport/mqtt/MqttTransport.h"
+#elif defined(DMQ_TRANSPORT_SERIAL_PORT)
+    #include "predef/dispatcher/Dispatcher.h"
+    #include "predef/transport/serial/SerialTransport.h"
+#elif defined(DMQ_TRANSPORT_ARM_LWIP_UDP)
+    #include "predef/dispatcher/Dispatcher.h"
+    #include "predef/transport/arm-lwip-udp/ArmLwipUdpTransport.h"
 #elif defined(DMQ_TRANSPORT_NONE)
     // Create a custom application-specific transport
 #else

DelegateMQ/External.cmake

@@ -74,6 +74,67 @@ if(DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_MQTT")
         set_and_check(MQTT_BINARY_DIR "/usr/local/bin")
     endif()
 endif()
+
+# ---------------------------------------------------------------------------
+# libserialport library
+# ---------------------------------------------------------------------------
+if(DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_SERIAL_PORT")
+    # Define the root of libserialport relative to the DelegateMQ source directory
+    # Structure: Workspace/DelegateMQ/src/delegate-mq/External.cmake -> Workspace/libserialport
+    set(SERIALPORT_ROOT "${DMQ_ROOT_DIR}/../../../libserialport")
+
+    if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+        # 1. Header: Found in the root of the source folder (libserialport.h)
+        set_and_check(SERIALPORT_INCLUDE_DIR "${SERIALPORT_ROOT}") 
+        
+        # 2. Library: Found in the Visual Studio build output folder
+        # Note: Change 'Debug' to 'Release' if building in Release mode
+        set_and_check(SERIALPORT_LIBRARY_DIR "${SERIALPORT_ROOT}/x64/Debug")
+
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        # 1. Header: Found in the root of the source folder
+        set_and_check(SERIALPORT_INCLUDE_DIR "${SERIALPORT_ROOT}") 
+        
+        # 2. Library: Found in the local build directory
+        # Standard Autotools builds (./configure && make) place .so files in the hidden .libs/ directory
+        if(EXISTS "${SERIALPORT_ROOT}/.libs")
+            set_and_check(SERIALPORT_LIBRARY_DIR "${SERIALPORT_ROOT}/.libs")
+        else()
+            # Fallback: Check root if built differently
+            set_and_check(SERIALPORT_LIBRARY_DIR "${SERIALPORT_ROOT}")
+        endif()
+    endif()
+endif()
+
+# ---------------------------------------------------------------------------
+# lwIP library (For ARM/Embedded)
+# ---------------------------------------------------------------------------
+if(DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_ARM_LWIP_UDP")
+    # Adjust this path if your lwIP root is different
+    set(LWIP_ROOT "${DMQ_ROOT_DIR}/../../../lwip")
+
+    # lwIP requires 3 main include directories for the socket API
+    set_and_check(LWIP_INCLUDE_DIR_1 "${LWIP_ROOT}/src/include")
+    set_and_check(LWIP_INCLUDE_DIR_2 "${LWIP_ROOT}/src/include/ipv4")
+    
+    # Often required for lwipopts.h or arch/cc.h. 
+    # NOTE: You may need to customize this depending on where your project keeps 'lwipopts.h'
+    # For now, we point to the generic 'contrib' ports if present, or just the root.
+    set(LWIP_INCLUDE_DIR_3 "${LWIP_ROOT}/contrib/ports/unix/port/include")
+
+    set(LWIP_INCLUDE_DIRS 
+        "${LWIP_INCLUDE_DIR_1}"
+        "${LWIP_INCLUDE_DIR_2}"
+        "${LWIP_INCLUDE_DIR_3}"
+    )
+    
+    # Collect core lwIP sources
+    file(GLOB_RECURSE LWIP_SOURCES 
+        "${LWIP_ROOT}/src/core/*.c"
+        "${LWIP_ROOT}/src/api/*.c"
+        "${LWIP_ROOT}/src/netif/*.c"
+    )
+endif()
 
 # ---------------------------------------------------------------------------
 # MessagePack
@@ -127,6 +188,74 @@ if(DMQ_THREAD STREQUAL "DMQ_THREAD_FREERTOS")
     )
 endif()
 
+# ---------------------------------------------------------------------------
+# ThreadX
+# ---------------------------------------------------------------------------
+if(DMQ_THREAD STREQUAL "DMQ_THREAD_THREADX")
+    set_and_check(THREADX_ROOT_DIR "${DMQ_ROOT_DIR}/../../../threadx")
+    
+    # Collect Common Core Sources
+    file(GLOB THREADX_SOURCES 
+        "${THREADX_ROOT_DIR}/common/src/*.c"
+        "${THREADX_ROOT_DIR}/common/inc/*.h"
+    )
+
+    # Note: You generally need to append architecture-specific port sources here
+    # Example for Windows Simulation (MSVC):
+    if(MSVC)
+        # file(GLOB PORT_SOURCES "${THREADX_ROOT_DIR}/ports/win32/vs_2019/src/*.c")
+        # list(APPEND THREADX_SOURCES ${PORT_SOURCES})
+    endif()
+endif()
+
+# ---------------------------------------------------------------------------
+# Zephyr
+# ---------------------------------------------------------------------------
+if(DMQ_THREAD STREQUAL "DMQ_THREAD_ZEPHYR")
+    # Zephyr is a build system, not just a library. 
+    # We typically do NOT manually glob source files here.
+    # The application's main CMakeLists.txt must call `find_package(Zephyr)` 
+    # which sets up the include paths and kernel linking automatically.
+
+    # Optional: Just verify the root directory exists if you want to be safe
+    set_and_check(ZEPHYR_ROOT_DIR "${DMQ_ROOT_DIR}/../../../zephyr")
+    
+    # Do NOT glob sources. Zephyr builds itself.
+endif()
+
+# ---------------------------------------------------------------------------
+# CMSIS-RTOS2
+# ---------------------------------------------------------------------------
+if(DMQ_THREAD STREQUAL "DMQ_THREAD_CMSIS_RTOS2")
+    # CMSIS is usually provided by the IDE (Keil/IAR) or a silicon vendor pack (STM32Cube).
+    # We do NOT glob sources here by default.
+    # Users must ensure the 'cmsis_os2.h' path is in their include path.
+endif()
+
+# ---------------------------------------------------------------------------
+# Qt Framework
+# ---------------------------------------------------------------------------
+if(DMQ_THREAD STREQUAL "DMQ_THREAD_QT")
+    add_compile_definitions(DMQ_THREAD_QT)
+    
+    # Find the Qt packages (Core is usually sufficient for QThread)
+    find_package(Qt6 COMPONENTS Core REQUIRED)
+    # Or Qt5: find_package(Qt5 COMPONENTS Core REQUIRED)
+
+    # Collect the source files
+    file(GLOB THREAD_SOURCES 
+        "${DMQ_ROOT_DIR}/predef/os/qt/*.cpp" 
+        "${DMQ_ROOT_DIR}/predef/os/qt/*.h" 
+    )
+    
+    # Important: Enable CMAKE_AUTOMOC for the Qt Meta-Object system 
+    # (needed for signals/slots in Thread.h)
+    set(CMAKE_AUTOMOC ON)
+    
+    # You might need to link Qt6::Core to your main target later:
+    # target_link_libraries(YourApp PRIVATE Qt6::Core)
+endif()
+
 # ---------------------------------------------------------------------------
 # spdlog
 # ---------------------------------------------------------------------------

DelegateMQ/Predef.cmake

@@ -12,6 +12,24 @@ elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_FREERTOS")
         "${DMQ_ROOT_DIR}/predef/os/freertos/*.c*" 
         "${DMQ_ROOT_DIR}/predef/os/freertos/*.h" 
     )
+elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_THREADX")
+    add_compile_definitions(DMQ_THREAD_THREADX)
+    file(GLOB THREAD_SOURCES 
+        "${DMQ_ROOT_DIR}/predef/os/threadx/*.c*" 
+        "${DMQ_ROOT_DIR}/predef/os/threadx/*.h" 
+    )
+elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_ZEPHYR")
+    add_compile_definitions(DMQ_THREAD_ZEPHYR)
+    file(GLOB THREAD_SOURCES 
+        "${DMQ_ROOT_DIR}/predef/os/zephyr/*.c*" 
+        "${DMQ_ROOT_DIR}/predef/os/zephyr/*.h" 
+    )
+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" 
+    )
 elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_NONE")
     add_compile_definitions(DMQ_THREAD_NONE)
 else()
@@ -56,9 +74,21 @@ elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_WIN32_PIPE")
 elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_WIN32_UDP")
     add_compile_definitions(DMQ_TRANSPORT_WIN32_UDP)
     file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/win32-udp/*.h")
+elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_WIN32_TCP")
+    add_compile_definitions(DMQ_TRANSPORT_WIN32_TCP)
+    file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/win32-tcp/*.h")
 elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_LINUX_UDP")
     add_compile_definitions(DMQ_TRANSPORT_LINUX_UDP)
     file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/linux-udp/*.h")
+elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_LINUX_TCP")
+    add_compile_definitions(DMQ_TRANSPORT_LINUX_TCP)
+    file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/linux-tcp/*.h")
+elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_SERIAL_PORT")
+    add_compile_definitions(DMQ_TRANSPORT_SERIAL_PORT)
+    file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/serial/*.h")
+elseif (DMQ_TRANSPORT STREQUAL "DMQ_TRANSPORT_ARM_LWIP_UDP")
+    add_compile_definitions(DMQ_TRANSPORT_ARM_LWIP_UDP)
+    file(GLOB TRANSPORT_SOURCES "${DMQ_ROOT_DIR}/predef/transport/arm-lwip-udp/*.h")
 else()
     message(FATAL_ERROR "Must set DMQ_TRANSPORT option.")
 endif()

DelegateMQ/delegate/DelegateOpt.h

@@ -10,6 +10,12 @@
 #if defined(DMQ_THREAD_FREERTOS)
     #include "predef/util/FreeRTOSClock.h"
     #include "predef/util/FreeRTOSMutex.h"
+#elif defined(DMQ_THREAD_THREADX)
+    #include "predef/util/ThreadXClock.h"
+    #include "predef/util/ThreadXMutex.h"
+#elif defined(DMQ_THREAD_CMSIS_RTOS2)
+    #include "predef/util/CmsisRtos2Clock.h"
+    #include "predef/util/CmsisRtos2Mutex.h"
 #elif defined(DMQ_THREAD_NONE)
     #include "predef/util/BareMetalClock.h"
 #endif
@@ -23,12 +29,23 @@ namespace dmq
     // Use the custom FreeRTOS wrapper
     using Clock = dmq::FreeRTOSClock;
 
+#elif defined(DMQ_THREAD_THREADX)
+    // Use the custom ThreadX wrapper
+    using Clock = dmq::ThreadXClock;
+
+#elif defined(DMQ_THREAD_ZEPHYR)
+    // Use the custom Zephyr wrapper
+    using Clock = dmq::ZephyrClock;
+
 #elif defined(DMQ_THREAD_NONE)
     // Assuming implemented the 'g_ticks' variable
     using Clock = dmq::BareMetalClock;
 
+ #elif defined(DMQ_THREAD_CMSIS_RTOS2)
+    using Clock = dmq::CmsisRtos2Clock;
+
 #else
-    // Windows / Linux / macOS (Standard)
+    // Windows / Linux / macOS / Qt
     using Clock = std::chrono::steady_clock;
 #endif
 
@@ -43,6 +60,20 @@ namespace dmq
     using Mutex = dmq::FreeRTOSMutex;
     using RecursiveMutex = dmq::FreeRTOSRecursiveMutex;
 
+#elif defined(DMQ_THREAD_THREADX)
+    // Use the custom ThreadX wrapper
+    using Mutex = dmq::ThreadXMutex;
+    using RecursiveMutex = dmq::ThreadXRecursiveMutex;
+
+#elif defined(DMQ_THREAD_ZEPHYR)
+    // Use the custom Zephyr wrapper
+    using Mutex = dmq::ZephyrMutex;
+    using RecursiveMutex = dmq::ZephyrRecursiveMutex;
+
+#elif defined(DMQ_THREAD_CMSIS_RTOS2)
+    using Mutex = dmq::CmsisRtos2Mutex;
+    using RecursiveMutex = dmq::CmsisRtos2RecursiveMutex;
+
 #elif defined(DMQ_THREAD_NONE)
     // Bare metal has no threads, so no locking is required.
     // We define a dummy "No-Op" mutex.
@@ -54,7 +85,7 @@ namespace dmq
     using RecursiveMutex = NullMutex;
 
 #else
-    // Windows / Linux / macOS
+    // Windows / Linux / macOS / Qt
     using Mutex = std::mutex;
     using RecursiveMutex = std::recursive_mutex;
 #endif

DelegateMQ/predef/dispatcher/Dispatcher.h

@@ -1,11 +1,27 @@
 #ifndef DISPATCHER_H
 #define DISPATCHER_H
 
-/// @file 
+/// @file Dispatcher.h
 /// @see https://github.com/endurodave/DelegateMQ
 /// David Lafreniere, 2025.
 /// 
-/// Dispatch callable argument data to a remote endpoint.
+/// @brief The bridge between the serialization layer and the physical transport layer.
+/// 
+/// @details
+/// The `Dispatcher` class is responsible for packaging serialized function arguments 
+/// into a valid DelegateMQ message and handing it off to the transport.
+/// 
+/// **Key Responsibilities:**
+/// 1. **Message Construction:** Creates the protocol header (`DmqHeader`) containing 
+///    the Remote ID and a monotonic Sequence Number.
+/// 2. **Stream Management:** Validates that the output stream is compatible 
+///    (expects `xostringstream`).
+/// 3. **Dispatch:** Forwards the header and the serialized payload (stream) to the 
+///    registered `ITransport::Send()` method.
+/// 
+/// **Usage:**
+/// This class is typically used internally by `DelegateRemote` to finalize a remote 
+/// procedure call before transmission.
 
 #include "delegate/IDispatcher.h"
 #include "predef/transport/DmqHeader.h"