vendor/symfony/event-dispatcher/Symfony/Component/EventDispatcher/ContainerAwareEventDispatcher.php

   1 <?php
   2
   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  */
  11
  12 namespace Symfony\Component\EventDispatcher;
  13
  14 use Symfony\Component\DependencyInjection\ContainerInterface;
  15
  16 /**
  17  * Lazily loads listeners and subscribers from the dependency injection
  18  * container
  19  *
  20  * @author Fabien Potencier <fabien@symfony.com>
  21  * @author Bernhard Schussek <bschussek@gmail.com>
  22  * @author Jordan Alliot <jordan.alliot@gmail.com>
  23  */
  24 class ContainerAwareEventDispatcher extends EventDispatcher
  25 {
  26     /**
  27      * The container from where services are loaded
  28      * @var ContainerInterface
  29      */
  30     private $container;
  31
  32     /**
  33      * The service IDs of the event listeners and subscribers
  34      * @var array
  35      */
  36     private $listenerIds = array();
  37
  38     /**
  39      * The services registered as listeners
  40      * @var array
  41      */
  42     private $listeners = array();
  43
  44     /**
  45      * Constructor.
  46      *
  47      * @param ContainerInterface $container A ContainerInterface instance
  48      */
  49     public function __construct(ContainerInterface $container)
  50     {
  51         $this->container = $container;
  52     }
  53
  54     /**
  55      * Adds a service as event listener
  56      *
  57      * @param string $eventName Event for which the listener is added
  58      * @param array  $callback  The service ID of the listener service & the method
  59      *                            name that has to be called
  60      * @param integer $priority The higher this value, the earlier an event listener
  61      *                            will be triggered in the chain.
  62      *                            Defaults to 0.
  63      *
  64      * @throws \InvalidArgumentException
  65      */
  66     public function addListenerService($eventName, $callback, $priority = 0)
  67     {
  68         if (!is_array($callback) || 2 !== count($callback)) {
  69             throw new \InvalidArgumentException('Expected an array("service", "method") argument');
  70         }
  71
  72         $this->listenerIds[$eventName][] = array($callback[0], $callback[1], $priority);
  73     }
  74
  75     public function removeListener($eventName, $listener)
  76     {
  77         $this->lazyLoad($eventName);
  78
  79         if (isset($this->listeners[$eventName])) {
  80             foreach ($this->listeners[$eventName] as $key => $l) {
  81                 foreach ($this->listenerIds[$eventName] as $i => $args) {
  82                     list($serviceId, $method, $priority) = $args;
  83                     if ($key === $serviceId.'.'.$method) {
  84                         if ($listener === array($l, $method)) {
  85                             unset($this->listeners[$eventName][$key]);
  86                             if (empty($this->listeners[$eventName])) {
  87                                 unset($this->listeners[$eventName]);
  88                             }
  89                             unset($this->listenerIds[$eventName][$i]);
  90                             if (empty($this->listenerIds[$eventName])) {
  91                                 unset($this->listenerIds[$eventName]);
  92                             }
  93                         }
  94                     }
  95                 }
  96             }
  97         }
  98
  99         parent::removeListener($eventName, $listener);
 100     }
 101
 102     /**
 103      * @see EventDispatcherInterface::hasListeners
 104      */
 105     public function hasListeners($eventName = null)
 106     {
 107         if (null === $eventName) {
 108             return (Boolean) count($this->listenerIds) || (Boolean) count($this->listeners);
 109         }
 110
 111         if (isset($this->listenerIds[$eventName])) {
 112             return true;
 113         }
 114
 115         return parent::hasListeners($eventName);
 116     }
 117
 118     /**
 119      * @see EventDispatcherInterface::getListeners
 120      */
 121     public function getListeners($eventName = null)
 122     {
 123         if (null === $eventName) {
 124             foreach (array_keys($this->listenerIds) as $serviceEventName) {
 125                 $this->lazyLoad($serviceEventName);
 126             }
 127         } else {
 128             $this->lazyLoad($eventName);
 129         }
 130
 131         return parent::getListeners($eventName);
 132     }
 133
 134     /**
 135      * Adds a service as event subscriber
 136      *
 137      * @param string $serviceId The service ID of the subscriber service
 138      * @param string $class     The service's class name (which must implement EventSubscriberInterface)
 139      */
 140     public function addSubscriberService($serviceId, $class)
 141     {
 142         foreach ($class::getSubscribedEvents() as $eventName => $params) {
 143             if (is_string($params)) {
 144                 $this->listenerIds[$eventName][] = array($serviceId, $params, 0);
 145             } elseif (is_string($params[0])) {
 146                 $this->listenerIds[$eventName][] = array($serviceId, $params[0], isset($params[1]) ? $params[1] : 0);
 147             } else {
 148                 foreach ($params as $listener) {
 149                     $this->listenerIds[$eventName][] = array($serviceId, $listener[0], isset($listener[1]) ? $listener[1] : 0);
 150                 }
 151             }
 152         }
 153     }
 154
 155     /**
 156      * {@inheritDoc}
 157      *
 158      * Lazily loads listeners for this event from the dependency injection
 159      * container.
 160      *
 161      * @throws \InvalidArgumentException if the service is not defined
 162      */
 163     public function dispatch($eventName, Event $event = null)
 164     {
 165         $this->lazyLoad($eventName);
 166
 167         return parent::dispatch($eventName, $event);
 168     }
 169
 170     public function getContainer()
 171     {
 172         return $this->container;
 173     }
 174
 175     /**
 176      * Lazily loads listeners for this event from the dependency injection
 177      * container.
 178      *
 179      * @param string $eventName The name of the event to dispatch. The name of
 180      *                          the event is the name of the method that is
 181      *                          invoked on listeners.
 182      */
 183     protected function lazyLoad($eventName)
 184     {
 185         if (isset($this->listenerIds[$eventName])) {
 186             foreach ($this->listenerIds[$eventName] as $args) {
 187                 list($serviceId, $method, $priority) = $args;
 188                 $listener = $this->container->get($serviceId);
 189
 190                 $key = $serviceId.'.'.$method;
 191                 if (!isset($this->listeners[$eventName][$key])) {
 192                     $this->addListener($eventName, array($listener, $method), $priority);
 193                 } elseif ($listener !== $this->listeners[$eventName][$key]) {
 194                     parent::removeListener($eventName, array($this->listeners[$eventName][$key], $method));
 195                     $this->addListener($eventName, array($listener, $method), $priority);
 196                 }
 197
 198                 $this->listeners[$eventName][$key] = $listener;
 199             }
 200         }
 201     }
 202 }