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

Open in your IDE?
  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 Psr\Container\ContainerInterface;
  18. /**
  19.  * Allows lazy loading of listener services.
  20.  *
  21.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  22.  */
  23. class ContainerAwareEventManager extends EventManager
  24. {
  25.     /**
  26.      * Map of registered listeners.
  27.      *
  28.      * <event> => <listeners>
  29.      */
  30.     private $listeners = [];
  31.     private $initialized = [];
  32.     private $methods = [];
  33.     private $container;
  35.     public function __construct(ContainerInterface $container)
  36.     {
  37.         $this->container = $container;
  38.     }
  40.     /**
  41.      * {@inheritdoc}
  42.      *
  43.      * @return void
  44.      */
  45.     public function dispatchEvent($eventName, EventArgs $eventArgs = null)
  46.     {
  47.         if (!isset($this->listeners[$eventName])) {
  48.             return;
  49.         }
  51.         $eventArgs = null === $eventArgs ? EventArgs::getEmptyInstance() : $eventArgs;
  53.         if (!isset($this->initialized[$eventName])) {
  54.             $this->initializeListeners($eventName);
  55.         }
  57.         foreach ($this->listeners[$eventName] as $hash => $listener) {
  58.             $listener->{$this->methods[$eventName][$hash]}($eventArgs);
  59.         }
  60.     }
  62.     /**
  63.      * {@inheritdoc}
  64.      *
  65.      * @return object[][]
  66.      */
  67.     public function getListeners($event = null)
  68.     {
  69.         if (null !== $event) {
  70.             if (!isset($this->initialized[$event])) {
  71.                 $this->initializeListeners($event);
  72.             }
  74.             return $this->listeners[$event];
  75.         }
  77.         foreach ($this->listeners as $event => $listeners) {
  78.             if (!isset($this->initialized[$event])) {
  79.                 $this->initializeListeners($event);
  80.             }
  81.         }
  83.         return $this->listeners;
  84.     }
  86.     /**
  87.      * {@inheritdoc}
  88.      *
  89.      * @return bool
  90.      */
  91.     public function hasListeners($event)
  92.     {
  93.         return isset($this->listeners[$event]) && $this->listeners[$event];
  94.     }
  96.     /**
  97.      * {@inheritdoc}
  98.      *
  99.      * @return void
  100.      */
  101.     public function addEventListener($events, $listener)
  102.     {
  103.         $hash = $this->getHash($listener);
  105.         foreach ((array) $events as $event) {
  106.             // Overrides listener if a previous one was associated already
  107.             // Prevents duplicate listeners on same event (same instance only)
  108.             $this->listeners[$event][$hash] = $listener;
  110.             if (\is_string($listener)) {
  111.                 unset($this->initialized[$event]);
  112.             } else {
  113.                 $this->methods[$event][$hash] = $this->getMethod($listener, $event);
  114.             }
  115.         }
  116.     }
  118.     /**
  119.      * {@inheritdoc}
  120.      *
  121.      * @return void
  122.      */
  123.     public function removeEventListener($events, $listener)
  124.     {
  125.         $hash = $this->getHash($listener);
  127.         foreach ((array) $events as $event) {
  128.             // Check if we actually have this listener associated
  129.             if (isset($this->listeners[$event][$hash])) {
  130.                 unset($this->listeners[$event][$hash]);
  131.             }
  133.             if (isset($this->methods[$event][$hash])) {
  134.                 unset($this->methods[$event][$hash]);
  135.             }
  136.         }
  137.     }
  139.     private function initializeListeners(string $eventName)
  140.     {
  141.         foreach ($this->listeners[$eventName] as $hash => $listener) {
  142.             if (\is_string($listener)) {
  143.                 $this->listeners[$eventName][$hash] = $listener = $this->container->get($listener);
  145.                 $this->methods[$eventName][$hash] = $this->getMethod($listener, $eventName);
  146.             }
  147.         }
  148.         $this->initialized[$eventName] = true;
  149.     }
  151.     /**
  152.      * @param string|object $listener
  153.      */
  154.     private function getHash($listener): string
  155.     {
  156.         if (\is_string($listener)) {
  157.             return '_service_'.$listener;
  158.         }
  160.         return spl_object_hash($listener);
  161.     }
  163.     /**
  164.      * @param object $listener
  165.      */
  166.     private function getMethod($listener, string $event): string
  167.     {
  168.         if (!method_exists($listener, $event) && method_exists($listener, '__invoke')) {
  169.             return '__invoke';
  170.         }
  172.         return $event;
  173.     }
  174. }