vendor/symfony/event-dispatcher/EventDispatcher.php line 230

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\EventDispatcher;
  14. use Psr\EventDispatcher\StoppableEventInterface;
  15. use Symfony\Component\EventDispatcher\Debug\WrappedListener;
  17. /**
  18.  * The EventDispatcherInterface is the central point of Symfony's event listener system.
  19.  *
  20.  * Listeners are registered on the manager and events are dispatched through the
  21.  * manager.
  22.  *
  23.  * @author Guilherme Blanco <[email protected]>
  24.  * @author Jonathan Wage <[email protected]>
  25.  * @author Roman Borschel <[email protected]>
  26.  * @author Bernhard Schussek <[email protected]>
  27.  * @author Fabien Potencier <[email protected]>
  28.  * @author Jordi Boggiano <[email protected]>
  29.  * @author Jordan Alliot <[email protected]>
  30.  * @author Nicolas Grekas <[email protected]>
  31.  */
  32. class EventDispatcher implements EventDispatcherInterface
  33. {
  34.     private $listeners = [];
  35.     private $sorted = [];
  36.     private $optimized;
  38.     public function __construct()
  39.     {
  40.         if (__CLASS__ === static::class) {
  41.             $this->optimized = [];
  42.         }
  43.     }
  45.     /**
  46.      * {@inheritdoc}
  47.      */
  48.     public function dispatch(object $event, string $eventName = null): object
  49.     {
  50.         $eventName = $eventName ?? \get_class($event);
  52.         if (null !== $this->optimized) {
  53.             $listeners = $this->optimized[$eventName] ?? (empty($this->listeners[$eventName]) ? [] : $this->optimizeListeners($eventName));
  54.         } else {
  55.             $listeners = $this->getListeners($eventName);
  56.         }
  58.         if ($listeners) {
  59.             $this->callListeners($listeners, $eventName, $event);
  60.         }
  62.         return $event;
  63.     }
  65.     /**
  66.      * {@inheritdoc}
  67.      */
  68.     public function getListeners(string $eventName = null)
  69.     {
  70.         if (null !== $eventName) {
  71.             if (empty($this->listeners[$eventName])) {
  72.                 return [];
  73.             }
  75.             if (!isset($this->sorted[$eventName])) {
  76.                 $this->sortListeners($eventName);
  77.             }
  79.             return $this->sorted[$eventName];
  80.         }
  82.         foreach ($this->listeners as $eventName => $eventListeners) {
  83.             if (!isset($this->sorted[$eventName])) {
  84.                 $this->sortListeners($eventName);
  85.             }
  86.         }
  88.         return array_filter($this->sorted);
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     public function getListenerPriority(string $eventName, $listener)
  95.     {
  96.         if (empty($this->listeners[$eventName])) {
  97.             return null;
  98.         }
  100.         if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  101.             $listener[0] = $listener[0]();
  102.             $listener[1] = $listener[1] ?? '__invoke';
  103.         }
  105.         foreach ($this->listeners[$eventName] as $priority => &$listeners) {
  106.             foreach ($listeners as &$v) {
  107.                 if ($v !== $listener && \is_array($v) && isset($v[0]) && $v[0] instanceof \Closure && 2 >= \count($v)) {
  108.                     $v[0] = $v[0]();
  109.                     $v[1] = $v[1] ?? '__invoke';
  110.                 }
  111.                 if ($v === $listener) {
  112.                     return $priority;
  113.                 }
  114.             }
  115.         }
  117.         return null;
  118.     }
  120.     /**
  121.      * {@inheritdoc}
  122.      */
  123.     public function hasListeners(string $eventName = null)
  124.     {
  125.         if (null !== $eventName) {
  126.             return !empty($this->listeners[$eventName]);
  127.         }
  129.         foreach ($this->listeners as $eventListeners) {
  130.             if ($eventListeners) {
  131.                 return true;
  132.             }
  133.         }
  135.         return false;
  136.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function addListener(string $eventName, $listener, int $priority = 0)
  142.     {
  143.         $this->listeners[$eventName][$priority][] = $listener;
  144.         unset($this->sorted[$eventName], $this->optimized[$eventName]);
  145.     }
  147.     /**
  148.      * {@inheritdoc}
  149.      */
  150.     public function removeListener(string $eventName, $listener)
  151.     {
  152.         if (empty($this->listeners[$eventName])) {
  153.             return;
  154.         }
  156.         if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  157.             $listener[0] = $listener[0]();
  158.             $listener[1] = $listener[1] ?? '__invoke';
  159.         }
  161.         foreach ($this->listeners[$eventName] as $priority => &$listeners) {
  162.             foreach ($listeners as $k => &$v) {
  163.                 if ($v !== $listener && \is_array($v) && isset($v[0]) && $v[0] instanceof \Closure && 2 >= \count($v)) {
  164.                     $v[0] = $v[0]();
  165.                     $v[1] = $v[1] ?? '__invoke';
  166.                 }
  167.                 if ($v === $listener) {
  168.                     unset($listeners[$k], $this->sorted[$eventName], $this->optimized[$eventName]);
  169.                 }
  170.             }
  172.             if (!$listeners) {
  173.                 unset($this->listeners[$eventName][$priority]);
  174.             }
  175.         }
  176.     }
  178.     /**
  179.      * {@inheritdoc}
  180.      */
  181.     public function addSubscriber(EventSubscriberInterface $subscriber)
  182.     {
  183.         foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
  184.             if (\is_string($params)) {
  185.                 $this->addListener($eventName, [$subscriber, $params]);
  186.             } elseif (\is_string($params[0])) {
  187.                 $this->addListener($eventName, [$subscriber, $params[0]], $params[1] ?? 0);
  188.             } else {
  189.                 foreach ($params as $listener) {
  190.                     $this->addListener($eventName, [$subscriber, $listener[0]], $listener[1] ?? 0);
  191.                 }
  192.             }
  193.         }
  194.     }
  196.     /**
  197.      * {@inheritdoc}
  198.      */
  199.     public function removeSubscriber(EventSubscriberInterface $subscriber)
  200.     {
  201.         foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
  202.             if (\is_array($params) && \is_array($params[0])) {
  203.                 foreach ($params as $listener) {
  204.                     $this->removeListener($eventName, [$subscriber, $listener[0]]);
  205.                 }
  206.             } else {
  207.                 $this->removeListener($eventName, [$subscriber, \is_string($params) ? $params : $params[0]]);
  208.             }
  209.         }
  210.     }
  212.     /**
  213.      * Triggers the listeners of an event.
  214.      *
  215.      * This method can be overridden to add functionality that is executed
  216.      * for each listener.
  217.      *
  218.      * @param callable[] $listeners The event listeners
  219.      * @param string     $eventName The name of the event to dispatch
  220.      * @param object     $event     The event object to pass to the event handlers/listeners
  221.      */
  222.     protected function callListeners(iterable $listeners, string $eventName, object $event)
  223.     {
  224.         $stoppable = $event instanceof StoppableEventInterface;
  226.         foreach ($listeners as $listener) {
  227.             if ($stoppable && $event->isPropagationStopped()) {
  228.                 break;
  229.             }
  230.             $listener($event, $eventName, $this);
  231.         }
  232.     }
  234.     /**
  235.      * Sorts the internal list of listeners for the given event by priority.
  236.      */
  237.     private function sortListeners(string $eventName)
  238.     {
  239.         krsort($this->listeners[$eventName]);
  240.         $this->sorted[$eventName] = [];
  242.         foreach ($this->listeners[$eventName] as &$listeners) {
  243.             foreach ($listeners as $k => &$listener) {
  244.                 if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  245.                     $listener[0] = $listener[0]();
  246.                     $listener[1] = $listener[1] ?? '__invoke';
  247.                 }
  248.                 $this->sorted[$eventName][] = $listener;
  249.             }
  250.         }
  251.     }
  253.     /**
  254.      * Optimizes the internal list of listeners for the given event by priority.
  255.      */
  256.     private function optimizeListeners(string $eventName): array
  257.     {
  258.         krsort($this->listeners[$eventName]);
  259.         $this->optimized[$eventName] = [];
  261.         foreach ($this->listeners[$eventName] as &$listeners) {
  262.             foreach ($listeners as &$listener) {
  263.                 $closure = &$this->optimized[$eventName][];
  264.                 if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  265.                     $closure = static function (...$args) use (&$listener, &$closure) {
  266.                         if ($listener[0] instanceof \Closure) {
  267.                             $listener[0] = $listener[0]();
  268.                             $listener[1] = $listener[1] ?? '__invoke';
  269.                         }
  270.                         ($closure = \Closure::fromCallable($listener))(...$args);
  271.                     };
  272.                 } else {
  273.                     $closure = $listener instanceof \Closure || $listener instanceof WrappedListener ? $listener : \Closure::fromCallable($listener);
  274.                 }
  275.             }
  276.         }
  278.         return $this->optimized[$eventName];
  279.     }
  280. }