<h2>Editing File: /usr/local/cpanel/base/3rdparty/roundcube/vendor/sabre/event/lib/WildcardEmitterTrait.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?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.
     */
    public 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 = &amp;$this-&gt;wildcardListeners;
        } else {
            $listeners = &amp;$this-&gt;listeners;
        }

        // Always fully reset the listener index. This is fairly sane for most
        // applications, because there's a clear &quot;event registering&quot; and &quot;event
        // emitting&quot; phase, but can be slow if there's a lot adding and removing
        // of listeners during emitting of events.
        $this-&gt;listenerIndex = [];

        if (!isset($listeners[$eventName])) {
            $listeners[$eventName] = [];
        }
        $listeners[$eventName][] = [$priority, $callBack];
    }

    /**
     * Subscribe to an event exactly once.
     */
    public function once(string $eventName, callable $callBack, int $priority = 100)
    {
        $wrapper = null;
        $wrapper = function () use ($eventName, $callBack, &amp;$wrapper) {
            $this-&gt;removeListener($eventName, $wrapper);

            return \call_user_func_array($callBack, \func_get_args());
        };

        $this-&gt;on($eventName, $wrapper, $priority);
    }

    /**
     * Emits an event.
     *
     * This method will return true if 0 or more listeners were successfully
     * 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.
     */
    public function emit(string $eventName, array $arguments = [], ?callable $continueCallBack = null): bool
    {
        if (\is_null($continueCallBack)) {
            foreach ($this-&gt;listeners($eventName) as $listener) {
                $result = \call_user_func_array($listener, $arguments);
                if (false === $result) {
                    return false;
                }
            }
        } else {
            $listeners = $this-&gt;listeners($eventName);
            $counter = \count($listeners);

            foreach ($listeners as $listener) {
                --$counter;
                $result = \call_user_func_array($listener, $arguments);
                if (false === $result) {
                    return false;
                }

                if ($counter &gt; 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[]
     */
    public function listeners(string $eventName): array
    {
        if (!\array_key_exists($eventName, $this-&gt;listenerIndex)) {
            // Create a new index.
            $listeners = [];
            if (isset($this-&gt;listeners[$eventName])) {
                foreach ($this-&gt;listeners[$eventName] as $listener) {
                    $listeners[] = $listener;
                }
            }

            foreach ($this-&gt;wildcardListeners as $wcEvent =&gt; $wcListeners) {
                // Wildcard match
                if (\substr($eventName, 0, \strlen($wcEvent)) === $wcEvent) {
                    foreach ($wcListeners as $listener) {
                        $listeners[] = $listener;
                    }
                }
            }

            // Sorting by priority
            \usort($listeners, static function ($l1, $l2) {
                return $l1[0] &lt;=&gt; $l2[0];
            });

            // Creating index
            $this-&gt;listenerIndex[$eventName] = \array_column($listeners, 1);
        }

        return $this-&gt;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.
     */
    public 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 = &amp;$this-&gt;wildcardListeners;
        } else {
            $listeners = &amp;$this-&gt;listeners;
        }

        if (!isset($listeners[$eventName])) {
            return false;
        }

        foreach ($listeners[$eventName] as $index =&gt; $check) {
            if ($check[1] === $listener) {
                // Remove listener
                unset($listeners[$eventName][$index]);
                // Reset index
                $this-&gt;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.
     */
    public function removeAllListeners(?string $eventName = null)
    {
        if (\is_null($eventName)) {
            $this-&gt;listeners = [];
            $this-&gt;wildcardListeners = [];
        } else {
            if ('*' === $eventName[\strlen($eventName) - 1]) {
                // Wildcard event
                unset($this-&gt;wildcardListeners[\substr($eventName, 0, -1)]);
            } else {
                unset($this-&gt;listeners[$eventName]);
            }
        }

        // Reset index
        $this-&gt;listenerIndex = [];
    }

    /**
     * The list of listeners.
     */
    protected $listeners = [];

    /**
     * The list of &quot;wildcard listeners&quot;.
     */
    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 = [];
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2F3rdparty%2Froundcube%2Fvendor%2Fsabre%2Fevent%2Flib'>Back to Directory</a>