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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
#pragma once
#include "Base.h"
#include "SelfResolvable.h"
#include <algorithm>
#include <cassert>
#include <functional>
#include <memory>
#include <utility>
#include <vector>
namespace cru {
class EventHandlerRevoker;
class EventBase : public Object, public SelfResolvable<EventBase> {
friend EventHandlerRevoker;
protected:
using EventHandlerToken = int;
/**
* 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;
inline EventHandlerRevoker CreateRevoker(EventHandlerToken token);
};
class EventHandlerRevoker {
friend EventBase;
private:
EventHandlerRevoker(ObjectResolver<EventBase>&& resolver,
EventBase::EventHandlerToken token)
: resolver_(std::move(resolver)), token_(token) {}
public:
/**
* Revoke the registered handler. If the event has already been destroyed or
* the handler is already revoked, nothing will be done.
*/
void operator()() const {
if (const auto event = resolver_.Resolve()) {
event->RemoveHandler(token_);
}
}
private:
ObjectResolver<EventBase> resolver_;
EventBase::EventHandlerToken token_;
};
inline EventHandlerRevoker EventBase::CreateRevoker(EventHandlerToken token) {
return EventHandlerRevoker(CreateResolver(), token);
}
struct IBaseEvent : public virtual Interface {
using SpyOnlyHandler = std::function<void()>;
virtual EventHandlerRevoker AddSpyOnlyHandler(SpyOnlyHandler handler) = 0;
};
// Provides an interface of event.
// IEvent only allow to add handler but not to raise the event. You may
// want to create an Event object and expose IEvent only so users won't
// be able to emit the event.
template <typename TEventArgs>
struct IEvent : virtual IBaseEvent {
using Args = TEventArgs;
using Handler = std::function<void(Args)>;
virtual EventHandlerRevoker AddHandler(Handler handler) = 0;
};
// A non-copyable non-movable Event class.
// It stores a list of event handlers.
template <typename TEventArgs>
class Event : public EventBase, public IEvent<TEventArgs> {
using typename IEvent<TEventArgs>::Args;
using typename IBaseEvent::SpyOnlyHandler;
using typename IEvent<TEventArgs>::Handler;
private:
struct HandlerData {
HandlerData(EventHandlerToken token, Handler handler)
: token(token), handler(std::move(handler)) {}
EventHandlerToken token;
Handler handler;
};
public:
EventHandlerRevoker AddSpyOnlyHandler(SpyOnlyHandler handler) override {
return AddHandler([handler = std::move(handler)](Args) { handler(); });
}
EventHandlerRevoker AddHandler(Handler handler) override {
const auto token = current_token_++;
this->handler_data_list_.emplace_back(token, std::move(handler));
return CreateRevoker(token);
}
// This method will make a copy of all handlers. Because user might delete a
// handler in a handler, which may lead to seg fault as the handler is
// deleted while being executed. Thanks to this behavior, all handlers will
// be taken a snapshot when Raise is called, so even if you delete a handler
// during this period, all handlers in the snapshot will be executed.
void Raise(Args args) {
std::vector<Handler> handlers;
handlers.reserve(this->handler_data_list_.size());
for (const auto& data : this->handler_data_list_) {
handlers.push_back(data.handler);
}
for (const auto& handler : handlers) {
handler(args);
}
}
protected:
void RemoveHandler(EventHandlerToken token) override {
const auto find_result = std::find_if(
this->handler_data_list_.cbegin(), this->handler_data_list_.cend(),
[token](const HandlerData& data) { return data.token == token; });
if (find_result != this->handler_data_list_.cend()) {
this->handler_data_list_.erase(find_result);
}
}
private:
std::vector<HandlerData> handler_data_list_;
EventHandlerToken current_token_ = 0;
};
namespace details {
struct EventHandlerRevokerDestroyer {
void operator()(EventHandlerRevoker* p) {
(*p)();
delete p;
}
};
} // namespace details
// A guard class for event revoker. Automatically revoke it when destroyed.
class EventHandlerRevokerGuard {
public:
EventHandlerRevokerGuard() = default;
explicit EventHandlerRevokerGuard(EventHandlerRevoker&& revoker)
: revoker_(new EventHandlerRevoker(std::move(revoker))) {}
EventHandlerRevoker Get() {
// revoker is only null when this is moved
// you shouldn't use a moved instance
assert(revoker_);
return *revoker_;
}
EventHandlerRevoker Release() { return std::move(*revoker_.release()); }
void Reset() { revoker_.reset(); }
void Reset(EventHandlerRevoker&& revoker) {
revoker_.reset(new EventHandlerRevoker(std::move(revoker)));
}
private:
std::unique_ptr<EventHandlerRevoker, details::EventHandlerRevokerDestroyer> revoker_;
};
class EventHandlerRevokerListGuard {
public:
void Add(EventHandlerRevoker&& revoker) {
event_revoker_guard_list_.push_back(EventHandlerRevokerGuard(std::move(revoker)));
}
EventHandlerRevokerListGuard& operator+=(EventHandlerRevoker&& revoker) {
this->Add(std::move(revoker));
return *this;
}
void Clear() { event_revoker_guard_list_.clear(); }
bool IsEmpty() const { return event_revoker_guard_list_.empty(); }
private:
std::vector<EventHandlerRevokerGuard> event_revoker_guard_list_;
};
} // namespace cru
|
