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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
|
<?php declare (strict_types=1);
namespace Sabre\Event;
/**
* Wildcard Emitter Trait
*
* This trait provides the implementation for WildCardEmitter
* Refer to that class for the full documentation about this
* trait.
*
* Normally you can just instantiate that class, but if you want to add
* emitter functionality to existing classes, using the trait might be a
* better way to do this.
*
* @copyright Copyright (C) fruux GmbH (https://fruux.com/)
* @author Evert Pot (http://evertpot.com/)
* @license http://sabre.io/license/ Modified BSD License
*/
trait WildcardEmitterTrait {
/**
* Subscribe to an event.
*
* @return void
*/
function on(string $eventName, callable $callBack, int $priority = 100) {
// If it ends with a wildcard, we use the wildcardListeners array
if ($eventName[\strlen($eventName) - 1] === '*') {
$eventName = \substr($eventName, 0, -1);
$listeners = & $this->wildcardListeners;
} else {
$listeners = & $this->listeners;
}
// Always fully reset the listener index. This is fairly sane for most
// applications, because there's a clear "event registering" and "event
// emitting" phase, but can be slow if there's a lot adding and removing
// of listeners during emitting of events.
$this->listenerIndex = [];
if (!isset($listeners[$eventName])) {
$listeners[$eventName] = [];
}
$listeners[$eventName][] = [$priority, $callBack];
}
/**
* Subscribe to an event exactly once.
*
* @return void
*/
function once(string $eventName, callable $callBack, int $priority = 100) {
$wrapper = null;
$wrapper = function() use ($eventName, $callBack, &$wrapper) {
$this->removeListener($eventName, $wrapper);
return \call_user_func_array($callBack, \func_get_args());
};
$this->on($eventName, $wrapper, $priority);
}
/**
* Emits an event.
*
* This method will return true if 0 or more listeners were succesfully
* handled. false is returned if one of the events broke the event chain.
*
* If the continueCallBack is specified, this callback will be called every
* time before the next event handler is called.
*
* If the continueCallback returns false, event propagation stops. This
* allows you to use the eventEmitter as a means for listeners to implement
* functionality in your application, and break the event loop as soon as
* some condition is fulfilled.
*
* Note that returning false from an event subscriber breaks propagation
* and returns false, but if the continue-callback stops propagation, this
* is still considered a 'successful' operation and returns true.
*
* Lastly, if there are 5 event handlers for an event. The continueCallback
* will be called at most 4 times.
*/
function emit(string $eventName, array $arguments = [], callable $continueCallBack = null) : bool {
if (\is_null($continueCallBack)) {
foreach ($this->listeners($eventName) as $listener) {
$result = \call_user_func_array($listener, $arguments);
if ($result === false) {
return false;
}
}
} else {
$listeners = $this->listeners($eventName);
$counter = \count($listeners);
foreach ($listeners as $listener) {
$counter--;
$result = \call_user_func_array($listener, $arguments);
if ($result === false) {
return false;
}
if ($counter > 0) {
if (!$continueCallBack()) break;
}
}
}
return true;
}
/**
* Returns the list of listeners for an event.
*
* The list is returned as an array, and the list of events are sorted by
* their priority.
*
* @return callable[]
*/
function listeners(string $eventName) : array {
if (!\array_key_exists($eventName, $this->listenerIndex)) {
// Create a new index.
$listeners = [];
$listenersPriority = [];
if (isset($this->listeners[$eventName])) foreach ($this->listeners[$eventName] as $listener) {
$listenersPriority[] = $listener[0];
$listeners[] = $listener[1];
}
foreach ($this->wildcardListeners as $wcEvent => $wcListeners) {
// Wildcard match
if (\substr($eventName, 0, \strlen($wcEvent)) === $wcEvent) {
foreach ($wcListeners as $listener) {
$listenersPriority[] = $listener[0];
$listeners[] = $listener[1];
}
}
}
// Sorting by priority
\array_multisort($listenersPriority, SORT_NUMERIC, $listeners);
// Creating index
$this->listenerIndex[$eventName] = $listeners;
}
return $this->listenerIndex[$eventName];
}
/**
* Removes a specific listener from an event.
*
* If the listener could not be found, this method will return false. If it
* was removed it will return true.
*/
function removeListener(string $eventName, callable $listener) : bool {
// If it ends with a wildcard, we use the wildcardListeners array
if ($eventName[\strlen($eventName) - 1] === '*') {
$eventName = \substr($eventName, 0, -1);
$listeners = & $this->wildcardListeners;
} else {
$listeners = & $this->listeners;
}
if (!isset($listeners[$eventName])) {
return false;
}
foreach ($listeners[$eventName] as $index => $check) {
if ($check[1] === $listener) {
// Remove listener
unset($listeners[$eventName][$index]);
// Reset index
$this->listenerIndex = [];
return true;
}
}
return false;
}
/**
* Removes all listeners.
*
* If the eventName argument is specified, all listeners for that event are
* removed. If it is not specified, every listener for every event is
* removed.
*
* @return void
*/
function removeAllListeners(string $eventName = null) {
if (\is_null($eventName)) {
$this->listeners = [];
$this->wildcardListeners = [];
} else {
if ($eventName[\strlen($eventName) - 1] === '*') {
// Wildcard event
unset($this->wildcardListeners[\substr($eventName, 0, -1)]);
} else {
unset($this->listeners[$eventName]);
}
}
// Reset index
$this->listenerIndex = [];
}
/**
* The list of listeners
*/
protected $listeners = [];
/**
* The list of "wildcard listeners".
*/
protected $wildcardListeners = [];
/**
* An index of listeners for a specific event name. This helps speeding
* up emitting events after all listeners have been set.
*
* If the list of listeners changes though, the index clears.
*/
protected $listenerIndex = [];
}
|
