aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/sabre/event/lib/WildcardEmitterTrait.php
diff options
context:
space:
mode:
authorMario <mario@mariovavti.com>2019-11-10 12:49:51 +0000
committerMario <mario@mariovavti.com>2019-11-10 14:10:03 +0100
commit580c3f4ffe9608d2beb56d418c68b3b112420e76 (patch)
tree82335d01179ac361d3f547a4b8e8c598d302e9f3 /vendor/sabre/event/lib/WildcardEmitterTrait.php
parentd22766f458a8539a40a57f3946459a9be1f21cd6 (diff)
downloadvolse-hubzilla-580c3f4ffe9608d2beb56d418c68b3b112420e76.tar.gz
volse-hubzilla-580c3f4ffe9608d2beb56d418c68b3b112420e76.tar.bz2
volse-hubzilla-580c3f4ffe9608d2beb56d418c68b3b112420e76.zip
another bulk of composer updates
(cherry picked from commit 6685381fd8db507493c3d7c1793f8c05c681bbce)
Diffstat (limited to 'vendor/sabre/event/lib/WildcardEmitterTrait.php')
-rw-r--r--vendor/sabre/event/lib/WildcardEmitterTrait.php264
1 files changed, 264 insertions, 0 deletions
diff --git a/vendor/sabre/event/lib/WildcardEmitterTrait.php b/vendor/sabre/event/lib/WildcardEmitterTrait.php
new file mode 100644
index 000000000..7d8d62c26
--- /dev/null
+++ b/vendor/sabre/event/lib/WildcardEmitterTrait.php
@@ -0,0 +1,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 = [];
+}