1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
From 14c8842ed8a37fecbc70d46e27b49ae929b0c85f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Bollo?= <jose.bollo@iot.bzh>
Date: Fri, 1 Feb 2019 15:37:44 +0100
Subject: [PATCH] Avoid casting from "const T&" to "void*"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Latest version of g++ refuse the cast
reinterpret_cast<void (Service::*)(void*)>(serviceFunction)
I made no investigation to know if the problem
is coming from the const or not.
Signed-off-by: José Bollo <jose.bollo@iot.bzh>
---
src/server/main/include/service-thread.h | 43 ++++++++++--------------
1 file changed, 18 insertions(+), 25 deletions(-)
diff --git a/src/server/main/include/service-thread.h b/src/server/main/include/service-thread.h
index 964d168..92b0ec8 100644
--- a/src/server/main/include/service-thread.h
+++ b/src/server/main/include/service-thread.h
@@ -9,78 +94,72 @@ public:
Join();
while (!m_eventQueue.empty()){
auto front = m_eventQueue.front();
- delete front.eventPtr;
+ delete front;
m_eventQueue.pop();
}
}
template <class T>
void Event(const T &event,
Service *servicePtr,
void (Service::*serviceFunction)(const T &))
{
- EventDescription description;
- description.serviceFunctionPtr =
- reinterpret_cast<void (Service::*)(void*)>(serviceFunction);
- description.servicePtr = servicePtr;
- description.eventFunctionPtr = &ServiceThread::EventCall<T>;
- description.eventPtr = new T(event);
+ EventCallerBase *ec = new EventCaller<T>(event, servicePtr, serviceFunction);
{
std::lock_guard<std::mutex> lock(m_eventQueueMutex);
- m_eventQueue.push(description);
+ m_eventQueue.push(ec);
}
m_waitCondition.notify_one();
}
protected:
- struct EventDescription {
- void (Service::*serviceFunctionPtr)(void *);
- Service *servicePtr;
- void (ServiceThread::*eventFunctionPtr)(const EventDescription &event);
- GenericEvent* eventPtr;
- };
-
- template <class T>
- void EventCall(const EventDescription &desc) {
- auto fun = reinterpret_cast<void (Service::*)(const T&)>(desc.serviceFunctionPtr);
- const T& eventLocale = *(static_cast<T*>(desc.eventPtr));
- (desc.servicePtr->*fun)(eventLocale);
- }
+ struct EventCallerBase {
+ virtual void fire() = 0;
+ virtual ~EventCallerBase() {}
+ };
+ template <class T>
+ struct EventCaller : public EventCallerBase {
+ T *event; Service *target; void (Service::*function)(const T&);
+ EventCaller(const T &e, Service *c, void (Service::*f)(const T&)) : event(new T(e)), target(c), function(f) {}
+ ~EventCaller() { delete event; }
+ void fire() { (target->*function)(*event); }
+ };
+
static void ThreadLoopStatic(ServiceThread *ptr) {
ptr->ThreadLoop();
}
void ThreadLoop(){
for (;;) {
- EventDescription description = {NULL, NULL, NULL, NULL};
+ EventCallerBase *ec = NULL;
{
std::unique_lock<std::mutex> ulock(m_eventQueueMutex);
if (m_quit)
return;
if (!m_eventQueue.empty()) {
- description = m_eventQueue.front();
+ ec = m_eventQueue.front();
m_eventQueue.pop();
} else {
m_waitCondition.wait(ulock);
}
}
- if (description.eventPtr != NULL) {
+ if (ec != NULL) {
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
- (this->*description.eventFunctionPtr)(description);
- delete description.eventPtr;
+ ec->fire();
}
UNHANDLED_EXCEPTION_HANDLER_END
+ delete ec;
}
}
}
std::thread m_thread;
std::mutex m_eventQueueMutex;
- std::queue<EventDescription> m_eventQueue;
+ std::queue<EventCallerBase*> m_eventQueue;
std::condition_variable m_waitCondition;
State m_state;
--
2.17.2
|
