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
|
#pragma once
#include <memory>
#include <unordered_map>
#include <vector>
#include <functional>
#include <iostream>
#include <typeindex>
#include <type_traits>
#include "Event.h"
#include "EventHandler.h"
//#include "keyCodes.h"
class EventManager {
public:
EventManager(const EventManager &) = delete;
const EventManager & operator=(const EventManager &) = delete;
static EventManager & get_instance() {
static EventManager instance;
return instance;
}
template <typename EventType>
void subscribe(EventHandler<EventType> && callback, int channel = 0);
template <typename EventType>
void unsubscribe(const EventHandler<EventType> &, int eventId);
template <typename EventType>
void trigger_event(const EventType & event, int channel);
template <typename EventType>
void queue_event(EventType&& event, int channel);
void dispatch_events();
private:
EventManager() = default;
std::vector<std::tuple<std::unique_ptr<Event>, int, std::type_index>> events_queue;
std::unordered_map<std::type_index, std::vector<std::unique_ptr<IEventHandlerWrapper>>> subscribers;
std::unordered_map<std::type_index, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>> subscribers_by_event_id;
};
template <typename EventType>
void EventManager::subscribe(EventHandler<EventType> && callback, int channel){
std::type_index event_type = typeid(EventType);
auto handler = std::make_unique<EventHandlerWrapper<EventType>>(callback);
if (channel) {
auto & handlers_map = subscribers_by_event_id[event_type];
auto handlers = handlers_map.find(channel);
if (handlers != handlers_map.end()) {
handlers->second.emplace_back(std::move(handler));
} else {
handlers_map[channel].emplace_back(std::move(handler));
}
} else {
subscribers[event_type].emplace_back(std::move(handler));
}
}
template <typename EventType>
void EventManager::queue_event(EventType&& event, int channel) {
std::type_index event_type = std::type_index(typeid(EventType));
std::unique_ptr<EventType> event_ptr = std::make_unique<EventType>(std::forward<EventType>(event));
std::tuple<std::unique_ptr<Event>, int, std::type_index> tuple(
std::move(event_ptr),
channel,
event_type
);
events_queue.push_back(std::move(tuple));
}
template <typename EventType>
void EventManager::trigger_event(const EventType & event, int eventId) {
std::type_index event_type = std::type_index(typeid(EventType));
if (eventId > 0) {
auto handlers_it = subscribers_by_event_id[event_type].find(eventId);
if (handlers_it != subscribers_by_event_id[event_type].end()) {
auto & callbacks = handlers_it->second;
for (auto it = callbacks.begin(); it != callbacks.end();) {
if ((*it)->exec(event)) {
it = callbacks.erase(it);
} else {
++it;
}
}
}
} else {
auto & handlers = subscribers[event_type];
for (auto & handler : handlers) {
handler->exec(event);
}
}
}
template <typename EventType>
void EventManager::unsubscribe(const EventHandler<EventType> & callback, int channel) {
std::type_index event_type(typeid(EventType));
const std::string handler_name = callback.target_type().name();
if (channel) {
auto subscriber_list = subscribers_by_event_id.find(event_type);
if (subscriber_list != subscribers_by_event_id.end()) {
auto& handlers_map = subscriber_list->second;
auto handlers = handlers_map.find(channel);
if (handlers != handlers_map.end()) {
auto& callbacks = handlers->second;
for (auto it = callbacks.begin(); it != callbacks.end(); ++it) {
if ((*it)->get_type() == handler_name) {
it = callbacks.erase(it);
return;
}
}
}
}
} else {
auto handlers_it = subscribers.find(event_type);
if (handlers_it != subscribers.end()) {
auto& handlers = handlers_it->second;
for (auto it = handlers.begin(); it != handlers.end(); ++it) {
if ((*it)->get_type() == handler_name) {
it = handlers.erase(it);
return;
}
}
}
}
}
|