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

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  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 <guilhermeblanco@hotmail.com>
  24.  * @author Jonathan Wage <jonwage@gmail.com>
  25.  * @author Roman Borschel <roman@code-factory.org>
  26.  * @author Bernhard Schussek <bschussek@gmail.com>
  27.  * @author Fabien Potencier <fabien@symfony.com>
  28.  * @author Jordi Boggiano <j.boggiano@seld.be>
  29.  * @author Jordan Alliot <jordan.alliot@gmail.com>
  30.  * @author Nicolas Grekas <p@tchwork.com>
  31.  */
  32. class EventDispatcher implements EventDispatcherInterface
  33. {
  34.     private array $listeners = [];
  35.     private array $sorted = [];
  36.     private array $optimized;
  38.     public function __construct()
  39.     {
  40.         if (__CLASS__ === static::class) {
  41.             $this->optimized = [];
  42.         }
  43.     }
  45.     public function dispatch(object $event, ?string $eventName = null): object
  46.     {
  47.         $eventName ??= $event::class;
  49.         if (isset($this->optimized)) {
  50.             $listeners = $this->optimized[$eventName] ?? (empty($this->listeners[$eventName]) ? [] : $this->optimizeListeners($eventName));
  51.         } else {
  52.             $listeners = $this->getListeners($eventName);
  53.         }
  55.         if ($listeners) {
  56.             $this->callListeners($listeners, $eventName, $event);
  57.         }
  59.         return $event;
  60.     }
  62.     public function getListeners(?string $eventName = null): array
  63.     {
  64.         if (null !== $eventName) {
  65.             if (empty($this->listeners[$eventName])) {
  66.                 return [];
  67.             }
  69.             if (!isset($this->sorted[$eventName])) {
  70.                 $this->sortListeners($eventName);
  71.             }
  73.             return $this->sorted[$eventName];
  74.         }
  76.         foreach ($this->listeners as $eventName => $eventListeners) {
  77.             if (!isset($this->sorted[$eventName])) {
  78.                 $this->sortListeners($eventName);
  79.             }
  80.         }
  82.         return array_filter($this->sorted);
  83.     }
  85.     public function getListenerPriority(string $eventName, callable|array $listener): ?int
  86.     {
  87.         if (empty($this->listeners[$eventName])) {
  88.             return null;
  89.         }
  91.         if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  92.             $listener[0] = $listener[0]();
  93.             $listener[1] ??= '__invoke';
  94.         }
  96.         foreach ($this->listeners[$eventName] as $priority => &$listeners) {
  97.             foreach ($listeners as &$v) {
  98.                 if ($v !== $listener && \is_array($v) && isset($v[0]) && $v[0] instanceof \Closure && 2 >= \count($v)) {
  99.                     $v[0] = $v[0]();
  100.                     $v[1] ??= '__invoke';
  101.                 }
  102.                 if ($v === $listener || ($listener instanceof \Closure && $v == $listener)) {
  103.                     return $priority;
  104.                 }
  105.             }
  106.         }
  108.         return null;
  109.     }
  111.     public function hasListeners(?string $eventName = null): bool
  112.     {
  113.         if (null !== $eventName) {
  114.             return !empty($this->listeners[$eventName]);
  115.         }
  117.         foreach ($this->listeners as $eventListeners) {
  118.             if ($eventListeners) {
  119.                 return true;
  120.             }
  121.         }
  123.         return false;
  124.     }
  126.     /**
  127.      * @return void
  128.      */
  129.     public function addListener(string $eventName, callable|array $listener, int $priority = 0)
  130.     {
  131.         $this->listeners[$eventName][$priority][] = $listener;
  132.         unset($this->sorted[$eventName], $this->optimized[$eventName]);
  133.     }
  135.     /**
  136.      * @return void
  137.      */
  138.     public function removeListener(string $eventName, callable|array $listener)
  139.     {
  140.         if (empty($this->listeners[$eventName])) {
  141.             return;
  142.         }
  144.         if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  145.             $listener[0] = $listener[0]();
  146.             $listener[1] ??= '__invoke';
  147.         }
  149.         foreach ($this->listeners[$eventName] as $priority => &$listeners) {
  150.             foreach ($listeners as $k => &$v) {
  151.                 if ($v !== $listener && \is_array($v) && isset($v[0]) && $v[0] instanceof \Closure && 2 >= \count($v)) {
  152.                     $v[0] = $v[0]();
  153.                     $v[1] ??= '__invoke';
  154.                 }
  155.                 if ($v === $listener || ($listener instanceof \Closure && $v == $listener)) {
  156.                     unset($listeners[$k], $this->sorted[$eventName], $this->optimized[$eventName]);
  157.                 }
  158.             }
  160.             if (!$listeners) {
  161.                 unset($this->listeners[$eventName][$priority]);
  162.             }
  163.         }
  164.     }
  166.     /**
  167.      * @return void
  168.      */
  169.     public function addSubscriber(EventSubscriberInterface $subscriber)
  170.     {
  171.         foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
  172.             if (\is_string($params)) {
  173.                 $this->addListener($eventName, [$subscriber, $params]);
  174.             } elseif (\is_string($params[0])) {
  175.                 $this->addListener($eventName, [$subscriber, $params[0]], $params[1] ?? 0);
  176.             } else {
  177.                 foreach ($params as $listener) {
  178.                     $this->addListener($eventName, [$subscriber, $listener[0]], $listener[1] ?? 0);
  179.                 }
  180.             }
  181.         }
  182.     }
  184.     /**
  185.      * @return void
  186.      */
  187.     public function removeSubscriber(EventSubscriberInterface $subscriber)
  188.     {
  189.         foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
  190.             if (\is_array($params) && \is_array($params[0])) {
  191.                 foreach ($params as $listener) {
  192.                     $this->removeListener($eventName, [$subscriber, $listener[0]]);
  193.                 }
  194.             } else {
  195.                 $this->removeListener($eventName, [$subscriber, \is_string($params) ? $params : $params[0]]);
  196.             }
  197.         }
  198.     }
  200.     /**
  201.      * Triggers the listeners of an event.
  202.      *
  203.      * This method can be overridden to add functionality that is executed
  204.      * for each listener.
  205.      *
  206.      * @param callable[] $listeners The event listeners
  207.      * @param string     $eventName The name of the event to dispatch
  208.      * @param object     $event     The event object to pass to the event handlers/listeners
  209.      *
  210.      * @return void
  211.      */
  212.     protected function callListeners(iterable $listeners, string $eventName, object $event)
  213.     {
  214.         $stoppable = $event instanceof StoppableEventInterface;
  216.         foreach ($listeners as $listener) {
  217.             if ($stoppable && $event->isPropagationStopped()) {
  218.                 break;
  219.             }
  220.             $listener($event, $eventName, $this);
  221.         }
  222.     }
  224.     /**
  225.      * Sorts the internal list of listeners for the given event by priority.
  226.      */
  227.     private function sortListeners(string $eventName): void
  228.     {
  229.         krsort($this->listeners[$eventName]);
  230.         $this->sorted[$eventName] = [];
  232.         foreach ($this->listeners[$eventName] as &$listeners) {
  233.             foreach ($listeners as &$listener) {
  234.                 if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  235.                     $listener[0] = $listener[0]();
  236.                     $listener[1] ??= '__invoke';
  237.                 }
  238.                 $this->sorted[$eventName][] = $listener;
  239.             }
  240.         }
  241.     }
  243.     /**
  244.      * Optimizes the internal list of listeners for the given event by priority.
  245.      */
  246.     private function optimizeListeners(string $eventName): array
  247.     {
  248.         krsort($this->listeners[$eventName]);
  249.         $this->optimized[$eventName] = [];
  251.         foreach ($this->listeners[$eventName] as &$listeners) {
  252.             foreach ($listeners as &$listener) {
  253.                 $closure = &$this->optimized[$eventName][];
  254.                 if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure && 2 >= \count($listener)) {
  255.                     $closure = static function (...$args) use (&$listener, &$closure) {
  256.                         if ($listener[0] instanceof \Closure) {
  257.                             $listener[0] = $listener[0]();
  258.                             $listener[1] ??= '__invoke';
  259.                         }
  260.                         ($closure = $listener(...))(...$args);
  261.                     };
  262.                 } else {
  263.                     $closure = $listener instanceof WrappedListener ? $listener : $listener(...);
  264.                 }
  265.             }
  266.         }
  268.         return $this->optimized[$eventName];
  269.     }
  270. }