vendor/symfony/doctrine-bridge/ContainerAwareEventManager.php line 47

  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\Bridge\Doctrine;
  14. use Doctrine\Common\EventArgs;
  15. use Doctrine\Common\EventManager;
  16. use Doctrine\Common\EventSubscriber;
  17. use Psr\Container\ContainerInterface;
  19. /**
  20.  * Allows lazy loading of listener and subscriber services.
  21.  *
  22.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  23.  */
  24. class ContainerAwareEventManager extends EventManager
  25. {
  26.     /**
  27.      * Map of registered listeners.
  28.      *
  29.      * <event> => <listeners>
  30.      */
  31.     private array $listeners = [];
  32.     private array $subscribers;
  33.     private array $initialized = [];
  34.     private bool $initializedSubscribers = false;
  35.     private array $methods = [];
  36.     private ContainerInterface $container;
  38.     /**
  39.      * @param list<string|EventSubscriber|array{string[], string|object}> $subscriberIds List of subscribers, subscriber ids, or [events, listener] tuples
  40.      */
  41.     public function __construct(ContainerInterface $container, array $subscriberIds = [])
  42.     {
  43.         $this->container = $container;
  44.         $this->subscribers = $subscriberIds;
  45.     }
  47.     public function dispatchEvent($eventName, EventArgs $eventArgs = null): void
  48.     {
  49.         if (!$this->initializedSubscribers) {
  50.             $this->initializeSubscribers();
  51.         }
  52.         if (!isset($this->listeners[$eventName])) {
  53.             return;
  54.         }
  56.         $eventArgs ??= EventArgs::getEmptyInstance();
  58.         if (!isset($this->initialized[$eventName])) {
  59.             $this->initializeListeners($eventName);
  60.         }
  62.         foreach ($this->listeners[$eventName] as $hash => $listener) {
  63.             $listener->{$this->methods[$eventName][$hash]}($eventArgs);
  64.         }
  65.     }
  67.     /**
  68.      * @return object[][]
  69.      */
  70.     public function getListeners($event = null): array
  71.     {
  72.         if (null === $event) {
  73.             trigger_deprecation('symfony/doctrine-bridge', '6.2', 'Calling "%s()" without an event name is deprecated. Call "getAllListeners()" instead.', __METHOD__);
  75.             return $this->getAllListeners();
  76.         }
  77.         if (!$this->initializedSubscribers) {
  78.             $this->initializeSubscribers();
  79.         }
  80.         if (!isset($this->initialized[$event])) {
  81.             $this->initializeListeners($event);
  82.         }
  84.         return $this->listeners[$event];
  85.     }
  87.     public function getAllListeners(): array
  88.     {
  89.         if (!$this->initializedSubscribers) {
  90.             $this->initializeSubscribers();
  91.         }
  93.         foreach ($this->listeners as $event => $listeners) {
  94.             if (!isset($this->initialized[$event])) {
  95.                 $this->initializeListeners($event);
  96.             }
  97.         }
  99.         return $this->listeners;
  100.     }
  102.     public function hasListeners($event): bool
  103.     {
  104.         if (!$this->initializedSubscribers) {
  105.             $this->initializeSubscribers();
  106.         }
  108.         return isset($this->listeners[$event]) && $this->listeners[$event];
  109.     }
  111.     public function addEventListener($events, $listener): void
  112.     {
  113.         if (!$this->initializedSubscribers) {
  114.             $this->initializeSubscribers();
  115.         }
  117.         $hash = $this->getHash($listener);
  119.         foreach ((array) $events as $event) {
  120.             // Overrides listener if a previous one was associated already
  121.             // Prevents duplicate listeners on same event (same instance only)
  122.             $this->listeners[$event][$hash] = $listener;
  124.             if (\is_string($listener)) {
  125.                 unset($this->initialized[$event]);
  126.             } else {
  127.                 $this->methods[$event][$hash] = $this->getMethod($listener, $event);
  128.             }
  129.         }
  130.     }
  132.     public function removeEventListener($events, $listener): void
  133.     {
  134.         if (!$this->initializedSubscribers) {
  135.             $this->initializeSubscribers();
  136.         }
  138.         $hash = $this->getHash($listener);
  140.         foreach ((array) $events as $event) {
  141.             // Check if we actually have this listener associated
  142.             if (isset($this->listeners[$event][$hash])) {
  143.                 unset($this->listeners[$event][$hash]);
  144.             }
  146.             if (isset($this->methods[$event][$hash])) {
  147.                 unset($this->methods[$event][$hash]);
  148.             }
  149.         }
  150.     }
  152.     public function addEventSubscriber(EventSubscriber $subscriber): void
  153.     {
  154.         if (!$this->initializedSubscribers) {
  155.             $this->initializeSubscribers();
  156.         }
  158.         parent::addEventSubscriber($subscriber);
  159.     }
  161.     public function removeEventSubscriber(EventSubscriber $subscriber): void
  162.     {
  163.         if (!$this->initializedSubscribers) {
  164.             $this->initializeSubscribers();
  165.         }
  167.         parent::removeEventSubscriber($subscriber);
  168.     }
  170.     private function initializeListeners(string $eventName)
  171.     {
  172.         $this->initialized[$eventName] = true;
  173.         foreach ($this->listeners[$eventName] as $hash => $listener) {
  174.             if (\is_string($listener)) {
  175.                 $this->listeners[$eventName][$hash] = $listener = $this->container->get($listener);
  177.                 $this->methods[$eventName][$hash] = $this->getMethod($listener, $eventName);
  178.             }
  179.         }
  180.     }
  182.     private function initializeSubscribers()
  183.     {
  184.         $this->initializedSubscribers = true;
  185.         foreach ($this->subscribers as $subscriber) {
  186.             if (\is_array($subscriber)) {
  187.                 $this->addEventListener(...$subscriber);
  188.                 continue;
  189.             }
  190.             if (\is_string($subscriber)) {
  191.                 $subscriber = $this->container->get($subscriber);
  192.             }
  193.             parent::addEventSubscriber($subscriber);
  194.         }
  195.         $this->subscribers = [];
  196.     }
  198.     private function getHash(string|object $listener): string
  199.     {
  200.         if (\is_string($listener)) {
  201.             return '_service_'.$listener;
  202.         }
  204.         return spl_object_hash($listener);
  205.     }
  207.     private function getMethod(object $listener, string $event): string
  208.     {
  209.         if (!method_exists($listener, $event) && method_exists($listener, '__invoke')) {
  210.             return '__invoke';
  211.         }
  213.         return $event;
  214.     }
  215. }