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
128
129
130
131
132
133
134
135
136
137
138
139
140
|
#include "EventManager.h"
namespace crepe {
template <typename EventType>
void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
std::type_index event_type = typeid(EventType);
std::unique_ptr<EventHandlerWrapper<EventType>> handler
= std::make_unique<EventHandlerWrapper<EventType>>(callback);
if (channel) {
std::unordered_map<int,
std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
handlers_map
= this->subscribers_by_event_id[event_type];
std::unordered_map<
int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
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 {
std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
= this->subscribers[event_type];
handlers.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);
this->events_queue.push_back(std::move(tuple));
}
template <typename EventType>
void EventManager::trigger_event(const EventType & event, int channel) {
std::type_index event_type = std::type_index(typeid(EventType));
if (channel > 0) {
std::unordered_map<int,
std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
handlers_map
= this->subscribers_by_event_id[event_type];
std::unordered_map<
int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
handlers_it
= handlers_map.find(channel);
if (handlers_it != handlers_map.end()) {
std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
= handlers_it->second;
for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
= handlers.begin();
it != handlers.end();++it) {
// stops when callback returns true
if((*it)->exec(event)){
break;
}
}
}
} else {
std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
= this->subscribers[event_type];
for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
= handlers.begin();
it != handlers.end();++it) {
// stops when callback returns true
if((*it)->exec(event)){
break;
}
}
}
}
template <typename EventType>
void EventManager::unsubscribe(const EventHandler<EventType> & callback,
int channel) {
std::type_index event_type(typeid(EventType));
std::string handler_name = callback.target_type().name();
if (channel) {
std::unordered_map<
std::type_index,
std::unordered_map<
int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
iterator subscriber_list
= this->subscribers_by_event_id.find(event_type);
if (subscriber_list != this->subscribers_by_event_id.end()) {
std::unordered_map<
int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
handlers_map
= subscriber_list->second;
std::unordered_map<
int,
std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
handlers
= handlers_map.find(channel);
if (handlers != handlers_map.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_type() == handler_name) {
it = callbacks.erase(it);
return;
}
}
}
}
} else {
std::unordered_map<std::type_index,
std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
iterator handlers_it
= this->subscribers.find(event_type);
if (handlers_it != this->subscribers.end()) {
std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
= handlers_it->second;
for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
= handlers.begin();
it != handlers.end(); ++it) {
if ((*it)->get_type() == handler_name) {
it = handlers.erase(it);
return;
}
}
}
}
}
}
|