Skip to content

Commit 08b8ed8

Browse files
endurodaveendurodave
committed
Update DelegateMQ library
1 parent 87de255 commit 08b8ed8

40 files changed

+1353
-395
lines changed

‎DelegateMQ/DelegateMQ.h‎

Lines changed: 30 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -71,46 +71,48 @@
7171
// - StdLib: Uses std::recursive_mutex
7272
// Valid for any platform where a Mutex is defined in DelegateOpt.h
7373
#if defined(DMQ_THREAD_STDLIB) || \
74+
defined(DMQ_THREAD_WIN32) || \
7475
defined(DMQ_THREAD_FREERTOS) || \
7576
defined(DMQ_THREAD_THREADX) || \
7677
defined(DMQ_THREAD_ZEPHYR) || \
7778
defined(DMQ_THREAD_CMSIS_RTOS2) || \
78-
defined(DMQ_THREAD_QT) || \
79-
defined(DMQ_THREAD_NONE)
79+
defined(DMQ_THREAD_QT)
8080
#include "delegate/MulticastDelegateSafe.h"
8181
#include "delegate/UnicastDelegateSafe.h"
82-
#include "delegate/SignalSafe.h"
8382
#endif
8483

8584
// -----------------------------------------------------------------------------
8685
// 3. Asynchronous "Fire and Forget" Delegates
8786
// -----------------------------------------------------------------------------
8887
// - FreeRTOS: OK
8988
// - Bare Metal: OK (Requires you to implement IThread wrapper for Event Loop)
90-
// - StdLib: OK
89+
// - StdLib / Win32: OK
9190
// Valid for any platform that implements the IThread interface
9291
#if defined(DMQ_THREAD_STDLIB) || \
92+
defined(DMQ_THREAD_WIN32) || \
9393
defined(DMQ_THREAD_FREERTOS) || \
9494
defined(DMQ_THREAD_THREADX) || \
9595
defined(DMQ_THREAD_ZEPHYR) || \
9696
defined(DMQ_THREAD_CMSIS_RTOS2) || \
97-
defined(DMQ_THREAD_QT) || \
98-
defined(DMQ_THREAD_NONE)
97+
defined(DMQ_THREAD_QT)
9998
#include "delegate/DelegateAsync.h"
10099
#endif
101100

102101
// -----------------------------------------------------------------------------
103102
// 4. Asynchronous "Blocking" Delegates (Wait for Result)
104103
// -----------------------------------------------------------------------------
105104
// Depends on Semaphore/Mutex and C++17 (std::any, std::optional).
106-
// Valid for StdLib (Windows/Linux), Qt, ThreadX, and FreeRTOS (if C++17 enabled).
107-
#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_QT) || defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_THREADX)
105+
// Valid for StdLib/Win32 (Windows/Linux), Qt, ThreadX, and FreeRTOS (if C++17 enabled).
106+
#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_THREADX)
108107
#include "delegate/DelegateAsyncWait.h"
109108
#endif
110109

111110
#if defined(DMQ_THREAD_STDLIB)
112111
#include "predef/os/stdlib/Thread.h"
113112
#include "predef/os/stdlib/ThreadMsg.h"
113+
#elif defined(DMQ_THREAD_WIN32)
114+
#include "predef/os/win32/Thread.h"
115+
#include "predef/os/win32/ThreadMsg.h"
114116
#elif defined(DMQ_THREAD_FREERTOS)
115117
#include "predef/os/freertos/Thread.h"
116118
#include "predef/os/freertos/ThreadMsg.h"
@@ -130,6 +132,7 @@
130132
// Bare metal: User must implement their own polling/interrupt logic
131133
#else
132134
#warning "Thread implementation not found."
135+
#define DMQ_THREAD_NONE
133136
#endif
134137

135138
#if defined(DMQ_SERIALIZE_MSGPACK)
@@ -191,11 +194,29 @@
191194
#include "predef/dispatcher/Dispatcher.h"
192195
#include "predef/transport/zephyr-udp/ZephyrUdpTransport.h"
193196
#elif defined(DMQ_TRANSPORT_NONE)
194-
// Create a custom application-specific transport
197+
// No built-in transport. Include the interface and dispatcher so application code
198+
// can implement a custom ITransport and use RemoteChannel with a mock or stub.
199+
#include "predef/dispatcher/Dispatcher.h"
200+
#include "predef/transport/ITransport.h"
195201
#else
196202
#warning "Transport implementation not found."
197203
#endif
198204

205+
// Include RemoteChannel whenever Dispatcher.h has been included (all transport
206+
// configurations including NONE, where a mock ITransport can be supplied).
207+
// RemoteChannel aggregates dispatcher, serializer, and stream into one object,
208+
// mirroring how Thread aggregates async delegate wiring behind a single IThread.
209+
#if defined(DMQ_TRANSPORT_ZEROMQ) || defined(DMQ_TRANSPORT_NNG) || \
210+
defined(DMQ_TRANSPORT_WIN32_PIPE) || defined(DMQ_TRANSPORT_WIN32_UDP) || \
211+
defined(DMQ_TRANSPORT_WIN32_TCP) || defined(DMQ_TRANSPORT_LINUX_UDP) || \
212+
defined(DMQ_TRANSPORT_LINUX_TCP) || defined(DMQ_TRANSPORT_MQTT) || \
213+
defined(DMQ_TRANSPORT_SERIAL_PORT) || defined(DMQ_TRANSPORT_ARM_LWIP_UDP) || \
214+
defined(DMQ_TRANSPORT_ARM_LWIP_NETCONN_UDP) || defined(DMQ_TRANSPORT_THREADX_UDP) || \
215+
defined(DMQ_TRANSPORT_STM32_UART) || defined(DMQ_TRANSPORT_ZEPHYR_UDP) || \
216+
defined(DMQ_TRANSPORT_NONE)
217+
#include "predef/dispatcher/RemoteChannel.h"
218+
#endif
219+
199220
#include "predef/util/Fault.h"
200221

201222
// Only include Timer and AsyncInvoke if threads exist

‎DelegateMQ/Predef.cmake‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,12 @@ if (DMQ_THREAD STREQUAL "DMQ_THREAD_STDLIB")
66
"${DMQ_ROOT_DIR}/predef/os/stdlib/*.c*"
77
"${DMQ_ROOT_DIR}/predef/os/stdlib/*.h"
88
)
9+
elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_WIN32")
10+
add_compile_definitions(DMQ_THREAD_WIN32)
11+
file(GLOB THREAD_SOURCES
12+
"${DMQ_ROOT_DIR}/predef/os/win32/*.c*"
13+
"${DMQ_ROOT_DIR}/predef/os/win32/*.h"
14+
)
915
elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_FREERTOS")
1016
add_compile_definitions(DMQ_THREAD_FREERTOS)
1117
file(GLOB THREAD_SOURCES

‎DelegateMQ/delegate/Delegate.h‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ class DelegateBase {
9999
};
100100

101101
template <class R>
102-
struct Delegate; // Not defined
102+
class Delegate; // Not defined
103103

104104
/// @brief Template base class for all delegates.
105105
/// @tparam RetType The return type of the bound delegate function.
@@ -116,11 +116,11 @@ class Delegate<RetType(Args...)> : public DelegateBase {
116116
/// @brief Clone an instance of a Delegate instance.
117117
/// @return A new Delegate instance created on the heap.
118118
/// @post The caller is responsible for deleting the instance.
119-
virtual Delegate* Clone() const = 0;
119+
virtual Delegate* Clone() const override = 0;
120120
};
121121

122122
template <class R>
123-
struct DelegateFree; // Not defined
123+
class DelegateFree; // Not defined
124124

125125
/// @brief `DelegateFree<>` class synchronously invokes a free target function.
126126
/// @tparam RetType The return type of the bound delegate function.
@@ -150,7 +150,7 @@ class DelegateFree<RetType(Args...)> : public Delegate<RetType(Args...)> {
150150
DelegateFree() = default;
151151

152152
/// @brief Destructor ensures empty when destroyed.
153-
~DelegateFree() { Clear(); }
153+
~DelegateFree() override { Clear(); }
154154

155155
/// @brief Bind a free function to the delegate.
156156
/// @details This method associates a free function (`func`) with the delegate.
@@ -276,7 +276,7 @@ class DelegateFree<RetType(Args...)> : public Delegate<RetType(Args...)> {
276276
};
277277

278278
template <class C, class R>
279-
struct DelegateMember; // Not defined
279+
class DelegateMember; // Not defined
280280

281281
/// @brief `DelegateMember<>` class synchronously invokes a class member target
282282
/// function using a class object pointer or shared pointer.
@@ -327,7 +327,7 @@ class DelegateMember<TClass, RetType(Args...)> : public Delegate<RetType(Args...
327327
DelegateMember() = default;
328328

329329
/// @brief Destructor ensures empty when destroyed.
330-
~DelegateMember() { Clear(); }
330+
~DelegateMember() override { Clear(); }
331331

332332
/// @brief Bind a member function to the delegate.
333333
/// @details This method associates a member function (`func`) with the delegate.
@@ -506,7 +506,7 @@ class DelegateMember<TClass, RetType(Args...)> : public Delegate<RetType(Args...
506506
};
507507

508508
template <class C, class R>
509-
struct DelegateMemberSp; // Not defined
509+
class DelegateMemberSp; // Not defined
510510

511511
/// @brief `DelegateMemberSp<>` class synchronously invokes a class member target
512512
/// function using a weak pointer.
@@ -545,7 +545,7 @@ class DelegateMemberSp<TClass, RetType(Args...)> : public Delegate<RetType(Args.
545545
DelegateMemberSp() = default;
546546

547547
/// @brief Destructor.
548-
~DelegateMemberSp() { Clear(); }
548+
~DelegateMemberSp() override { Clear(); }
549549

550550
/// @brief Bind a member function to the delegate.
551551
void Bind(SharedPtr object, MemberFunc func) {
@@ -697,7 +697,7 @@ class DelegateFunction<RetType(Args...)> : public Delegate<RetType(Args...)> {
697697
DelegateFunction() = default;
698698

699699
/// @brief Destructor ensures empty when destroyed.
700-
~DelegateFunction() { Clear(); }
700+
~DelegateFunction() override { Clear(); }
701701

702702
/// @brief Bind a member function to the delegate.
703703
/// @details This method associates a member function (`func`) with the delegate.

‎DelegateMQ/delegate/DelegateAsync.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,7 @@ class DelegateAsyncMsg : public DelegateMsg
102102
};
103103

104104
template <class R>
105-
struct DelegateFreeAsync; // Not defined
105+
class DelegateFreeAsync; // Not defined
106106

107107
/// @brief `DelegateFreeAsync<>` class asynchronously invokes a free target function.
108108
/// @tparam RetType The return type of the bound delegate function.
@@ -351,7 +351,7 @@ class DelegateFreeAsync<RetType(Args...)> : public DelegateFree<RetType(Args...)
351351
};
352352

353353
template <class C, class R>
354-
struct DelegateMemberAsync; // Not defined
354+
class DelegateMemberAsync; // Not defined
355355

356356
/// @brief `DelegateMemberAsync<>` class asynchronously invokes a class member target function.
357357
/// @tparam TClass The class type that contains the member function.
@@ -665,7 +665,7 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
665665
};
666666

667667
template <class C, class R>
668-
struct DelegateMemberAsyncSp; // Not defined
668+
class DelegateMemberAsyncSp; // Not defined
669669

670670
/// @brief `DelegateMemberAsyncSp<>` class asynchronously invokes a class member target function
671671
/// using a weak pointer (safe from use-after-free).
@@ -908,7 +908,7 @@ class DelegateMemberAsyncSp<TClass, RetType(Args...)> : public DelegateMemberSp<
908908
};
909909

910910
template <class R>
911-
struct DelegateFunctionAsync; // Not defined
911+
class DelegateFunctionAsync; // Not defined
912912

913913
/// @brief `DelegateFunctionAsync<>` class asynchronously invokes a `std::function` target function.
914914
/// @details Caution when binding to a `std::function` using this class. `std::function` cannot be

‎DelegateMQ/delegate/DelegateAsyncWait.h‎

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -140,7 +140,7 @@ class DelegateAsyncWaitMsg : public DelegateMsg
140140
};
141141

142142
template <class R>
143-
struct DelegateFreeAsyncWait; // Not defined
143+
class DelegateFreeAsyncWait; // Not defined
144144

145145
/// @brief `DelegateFreeAsyncWait<>` class asynchronously block invokes a free target function.
146146
/// @tparam RetType The return type of the bound delegate function.
@@ -238,10 +238,11 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
238238
if (&rhs != this) {
239239
BaseType::operator=(std::move(rhs));
240240
m_thread = rhs.m_thread; // Use the resource
241-
m_priority = rhs.m_priority;
242-
m_timeout = rhs.m_timeout;
241+
m_priority = rhs.m_priority;
242+
m_timeout = rhs.m_timeout;
243243
m_success = rhs.m_success;
244244
m_retVal = rhs.m_retVal;
245+
rhs.Clear();
245246
}
246247
return *this;
247248
}
@@ -492,7 +493,7 @@ class DelegateFreeAsyncWait<RetType(Args...)> : public DelegateFree<RetType(Args
492493
};
493494

494495
template <class C, class R>
495-
struct DelegateMemberAsyncWait; // Not defined
496+
class DelegateMemberAsyncWait; // Not defined
496497

497498
/// @brief `DelegateMemberAsyncWait<>` class asynchronously block invokes a class member target function.
498499
/// @tparam TClass The class type that contains the member function.
@@ -674,10 +675,11 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
674675
if (&rhs != this) {
675676
BaseType::operator=(std::move(rhs));
676677
m_thread = rhs.m_thread; // Use the resource
677-
m_priority = rhs.m_priority;
678-
m_timeout = rhs.m_timeout;
678+
m_priority = rhs.m_priority;
679+
m_timeout = rhs.m_timeout;
679680
m_success = rhs.m_success;
680681
m_retVal = rhs.m_retVal;
682+
rhs.Clear();
681683
}
682684
return *this;
683685
}
@@ -928,7 +930,7 @@ class DelegateMemberAsyncWait<TClass, RetType(Args...)> : public DelegateMember<
928930
};
929931

930932
template <class C, class R>
931-
struct DelegateMemberAsyncWaitSp; // Not defined
933+
class DelegateMemberAsyncWaitSp; // Not defined
932934

933935
/// @brief `DelegateMemberAsyncWaitSp<>` class asynchronously block invokes a class member target function
934936
/// using a weak/shared pointer semantics.
@@ -1027,10 +1029,11 @@ class DelegateMemberAsyncWaitSp<TClass, RetType(Args...)> : public DelegateMembe
10271029
if (&rhs != this) {
10281030
BaseType::operator=(std::move(rhs));
10291031
m_thread = rhs.m_thread; // Use the resource
1030-
m_priority = rhs.m_priority;
1031-
m_timeout = rhs.m_timeout;
1032+
m_priority = rhs.m_priority;
1033+
m_timeout = rhs.m_timeout;
10321034
m_success = rhs.m_success;
10331035
m_retVal = rhs.m_retVal;
1036+
rhs.Clear();
10341037
}
10351038
return *this;
10361039
}
@@ -1281,7 +1284,7 @@ class DelegateMemberAsyncWaitSp<TClass, RetType(Args...)> : public DelegateMembe
12811284
};
12821285

12831286
template <class R>
1284-
struct DelegateFunctionAsyncWait; // Not defined
1287+
class DelegateFunctionAsyncWait; // Not defined
12851288

12861289
/// @brief `DelegateFunctionAsyncWait<>` class asynchronously block invokes a std::function target function.
12871290
///
@@ -1382,10 +1385,11 @@ class DelegateFunctionAsyncWait<RetType(Args...)> : public DelegateFunction<RetT
13821385
if (&rhs != this) {
13831386
BaseType::operator=(std::move(rhs));
13841387
m_thread = rhs.m_thread; // Use the resource
1385-
m_priority = rhs.m_priority;
1386-
m_timeout = rhs.m_timeout;
1388+
m_priority = rhs.m_priority;
1389+
m_timeout = rhs.m_timeout;
13871390
m_success = rhs.m_success;
13881391
m_retVal = rhs.m_retVal;
1392+
rhs.Clear();
13891393
}
13901394
return *this;
13911395
}

0 commit comments

Comments
 (0)