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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
#pragma once
#include "base.hpp"
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <utility>
namespace cru {
class EventRevoker;
namespace details {
// Base class of all Event<T...>.
// It erases event args types and provides a
// unified form to create event revoker and
// revoke(remove) handler.
class EventBase {
friend EventRevoker;
protected:
using EventHandlerToken = long;
EventBase() : resolver_(new EventBase*(this)) {}
EventBase(const EventBase& other) = delete;
EventBase(EventBase&& other) = delete;
EventBase& operator=(const EventBase& other) = delete;
EventBase& operator=(EventBase&& other) = delete;
virtual ~EventBase() = default;
// Remove the handler with the given token. If the token
// corresponds to no handler (which might have be revoked
// before), then nothing will be done.
virtual void RemoveHandler(EventHandlerToken token) = 0;
// Create a revoker with the given token.
inline EventRevoker CreateRevoker(EventHandlerToken token);
private:
std::shared_ptr<EventBase*> resolver_;
};
} // namespace details
// A copyable and movable event revoker.
// Call function call operator to revoke the handler.
class EventRevoker {
friend class ::cru::details::EventBase;
private:
EventRevoker(const std::shared_ptr<details::EventBase*>& resolver,
details::EventBase::EventHandlerToken token)
: weak_resolver_(resolver), token_(token) {}
public:
EventRevoker(const EventRevoker& other) = default;
EventRevoker(EventRevoker&& other) = default;
EventRevoker& operator=(const EventRevoker& other) = default;
EventRevoker& operator=(EventRevoker&& other) = default;
~EventRevoker() = default;
// Revoke the registered handler. If the event has already
// been destroyed, then nothing will be done. If one of the
// copies calls this, then other copies's calls will have no
// effect. (They have the same token.)
void operator()() const {
const auto true_resolver = weak_resolver_.lock();
// if true_resolver is nullptr, then the event has been destroyed.
if (true_resolver) {
(*true_resolver)->RemoveHandler(token_);
}
}
private:
std::weak_ptr<details::EventBase*> weak_resolver_;
details::EventBase::EventHandlerToken token_;
};
inline EventRevoker details::EventBase::CreateRevoker(EventHandlerToken token) {
return EventRevoker(resolver_, token);
}
// A non-copyable non-movable Event class.
// It stores a list of event handlers.
template <typename... TArgs>
class Event : public details::EventBase {
public:
using EventHandler = std::function<void(TArgs...)>;
Event() = default;
Event(const Event&) = delete;
Event& operator=(const Event&) = delete;
Event(Event&&) = delete;
Event& operator=(Event&&) = delete;
~Event() = default;
EventRevoker AddHandler(const EventHandler& handler) {
const auto token = current_token_++;
handlers_.emplace(token, handler);
return CreateRevoker(token);
}
EventRevoker AddHandler(EventHandler&& handler) {
const auto token = current_token_++;
handlers_.emplace(token, std::move(handler));
return CreateRevoker(token);
}
template <typename FArg>
EventRevoker AddHandler(FArg&& handler) {
static_assert(std::is_invocable_v<FArg, TArgs...>,
"Handler not invocable.");
const auto token = current_token_++;
handlers_.emplace(token, EventHandler(std::forward<FArg>(handler)));
return CreateRevoker(token);
}
template <typename... FArg>
void Raise(FArg&&... args) {
// copy the handlers to a list, because the handler might be removed
// during executing, and the handler with its data will be destroyed.
// if the handler is a lambda with member data, then the member data
// will be destroyed and result in seg fault.
std::list<EventHandler> handlers;
for (const auto& [key, handler] : handlers_) handlers.push_back(handler);
for (const auto& handler : handlers) handler(std::forward<FArg>(args)...);
}
protected:
void RemoveHandler(EventHandlerToken token) override {
auto find_result = handlers_.find(token);
if (find_result != handlers_.cend()) handlers_.erase(find_result);
}
private:
std::map<EventHandlerToken, EventHandler> handlers_{};
EventHandlerToken current_token_ = 0;
};
namespace details {
struct EventRevokerGuardDestroyer {
void operator()(EventRevoker* p) const {
(*p)();
delete p;
}
};
} // namespace details
class EventRevokerGuard {
public:
explicit EventRevokerGuard(EventRevoker revoker)
: revoker_(new EventRevoker(std::move(revoker))) {}
EventRevokerGuard(const EventRevokerGuard& other) = delete;
EventRevokerGuard(EventRevokerGuard&& other) = default;
EventRevokerGuard& operator=(const EventRevokerGuard& other) = delete;
EventRevokerGuard& operator=(EventRevokerGuard&& other) = default;
~EventRevokerGuard() = default;
EventRevoker Get() const { return *revoker_; }
private:
std::unique_ptr<EventRevoker, details::EventRevokerGuardDestroyer> revoker_;
};
} // namespace cru
|
