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
|
#include "eventManager.h"
void EventManager::shutdown()
{
m_subscribers.clear();
}
void EventManager::subscribe(int eventType, std::unique_ptr<IEventHandlerWrapper>&& handler, int eventId)
{
if (eventId) {
std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscribers = m_subscribersByEventId.find(eventType);
if (subscribers != m_subscribersByEventId.end()) {
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscribers->second;
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlers = handlersMap.find(eventId);
if (handlers != handlersMap.end()) {
handlers->second.emplace_back(std::move(handler));
return;
}
}
m_subscribersByEventId[eventType][eventId].emplace_back(std::move(handler));
} else {
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator subscribers = m_subscribers.find(eventType);
if (subscribers != m_subscribers.end()) {
std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = subscribers->second;
for (std::unique_ptr<IEventHandlerWrapper>& it : handlers) {
if (it->getType() == handler->getType()) {
// log for double register
return;
}
}
handlers.emplace_back(std::move(handler));
} else {
m_subscribers[eventType].emplace_back(std::move(handler));
}
}
}
void EventManager::unsubscribe(int eventType, const std::string& handlerName, int eventId)
{
if (eventId) {
std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscribers = m_subscribersByEventId.find(eventType);
if (subscribers != m_subscribersByEventId.end()) {
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscribers->second;
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlers = handlersMap.find(eventId);
if (handlers != handlersMap.end()) {
std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlers->second;
for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = callbacks.begin(); it != callbacks.end(); ++it) {
if (it->get()->getType() == handlerName) {
it = callbacks.erase(it);
return;
}
}
}
}
} else {
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlersIt = m_subscribers.find(eventType);
if (handlersIt != m_subscribers.end()) {
std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = handlersIt->second;
for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = handlers.begin(); it != handlers.end(); ++it) {
if (it->get()->getType() == handlerName) {
it = handlers.erase(it);
return;
}
}
}
}
}
void EventManager::triggerEvent(const Event& event_, int eventId)
{
std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = m_subscribers[event_.getEventType()];
for (std::unique_ptr<IEventHandlerWrapper>& handler : handlers) {
handler->exec(event_);
}
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = m_subscribersByEventId[event_.getEventType()];
std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlersIt = handlersMap.find(eventId);
if (handlersIt != handlersMap.end()) {
std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlersIt->second;
for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = callbacks.begin(); it != callbacks.end();) {
std::unique_ptr<IEventHandlerWrapper>& handler = *it;
handler->exec(event_);
if (handler->isDestroyOnSuccess()) {
it = callbacks.erase(it);
} else {
++it;
}
}
}
}
void EventManager::queueEvent(std::unique_ptr<Event>&& event_, int eventId)
{
m_eventsQueue.emplace_back(std::move(event_), eventId);
}
void EventManager::dispatchEvents()
{
for (std::vector<std::pair<std::unique_ptr<Event>, int>>::iterator eventIt = m_eventsQueue.begin(); eventIt != m_eventsQueue.end();) {
if (!eventIt->first.get()->getHandled()) {
triggerEvent(*eventIt->first.get(), eventIt->second);
eventIt = m_eventsQueue.erase(eventIt);
} else {
++eventIt;
}
}
}
|