symfony · znerol · Nov 19, 2014 · Nov 20, 2014 · Nov 20, 2014 · Nov 21, 2014
diff --git a/src/Symfony/Component/EventDispatcher/CompiledEventDispatcher.php b/src/Symfony/Component/EventDispatcher/CompiledEventDispatcher.php
@@ -0,0 +1,249 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+use Symfony\Component\DependencyInjection\IntrospectableContainerInterface;
+
+/**
+ * A performance optimized container aware event dispatcher.
+ *
+ * This version of the event dispatcher contains the following optimizations
+ * in comparison to the Symfony event dispatcher component:
+ *
+ * <dl>
+ *   <dt>Faster instantiation of the event dispatcher service</dt>
+ *   <dd>
+ *     Instead of calling <code>addSubscriberService</code> once for each
+ *     subscriber, a precompiled array of listener definitions is passed
+ *     directly to the constructor. This is faster by an order of magnitude.
+ *     The listeners are collected and prepared using a compiler
+ *     pass.
+ *   </dd>
+ *   <dt>Lazy instantiation of listeners</dt>
+ *   <dd>
+ *     Services are only retrieved from the container just before invocation.
+ *     Especially when dispatching the KernelEvents::REQUEST event, this leads
+ *     to a more timely invocation of the first listener. Overall dispatch
+ *     runtime is not affected by this change though.
+ *   </dd>
+ * </dl>
+ */
+class CompiledEventDispatcher implements EventDispatcherInterface
+{
+    /**
+     * The service container.
+     *
+     * @var IntrospectableContainerInterface
+     */
+    private $container;
+
+    /**
+     * Listener definitions.
+     *
+     * A nested array of listener definitions keyed by event name and priority.
+     * A listener definition is an associative array with one of the following key
+     * value pairs:
+     * - callable: A callable listener
+     * - service: An array of the form
+     *     array('id' => service id, 'method' => method name)
+     *
+     * A service entry will be resolved to a callable only just before its
+     * invocation.
+     *
+     * @var array
+     */
+    private $listeners;
+
+    /**
+     * Whether listeners need to be sorted prior to dispatch, keyed by event name.
+     *
+     * @var array
+     */
+    private $unsorted = array();
+
+    /**
+     * Constructs a container aware event dispatcher.
+     *
+     * @param IntrospectableContainerInterface $container
+     *   The service container.
+     * @param array $listeners
+     *   A nested array of listener definitions keyed by event name and priority.
+     *   The array is expected to be ordered by priority. A listener definition is
+     *   an associative array with one of the following key value pairs:
+     *   - callable: A callable listener
+     *   - service: An array of the form
+     *       array('id' => service id, 'method' => method name)
+     *   A service entry will be resolved to a callable only just before its
+     *   invocation.
+     */
+    public function __construct(IntrospectableContainerInterface $container, array $listeners = array())
+    {
+        $this->container = $container;
+        $this->listeners = $listeners;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function dispatch($eventName, Event $event = null)
+    {
+        if (null === $event) {
+            $event = new Event();
+        }
+
+        $event->setDispatcher($this);
+        $event->setName($eventName);
+
+        if (isset($this->listeners[$eventName])) {
+            // Sort listeners if necessary.
+            if (isset($this->unsorted[$eventName])) {
+                krsort($this->listeners[$eventName]);
+                unset($this->unsorted[$eventName]);
+            }
+
+            // Invoke listeners and resolve callables if necessary.
+            foreach ($this->listeners[$eventName] as &$definitions) {
+                foreach ($definitions as &$definition) {
+                    if (!isset($definition['callable'])) {
+                        $definition['callable'] = array($this->container->get($definition['service']['id']), $definition['service']['method']);
+                    }
+
+                    call_user_func($definition['callable'], $event, $eventName, $this);
+                    if ($event->isPropagationStopped()) {
+                        return $event;
+                    }
+                }
+            }
+        }
+
+        return $event;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListeners($eventName = null)
+    {
+        $result = array();
+
+        if (null === $eventName) {
+            // If event name was omitted, collect all listeners of all events.
+            foreach (array_keys($this->listeners) as $eventName) {
+                $listeners = $this->getListeners($eventName);
+                if (!empty($listeners)) {
+                    $result[$eventName] = $listeners;
+                }
+            }
+
+            return $result;
+        }
+
+        if (!isset($this->listeners[$eventName])) {
+            return $result;
+        }
+
+        // Sort listeners if necessary.
+        if (isset($this->unsorted[$eventName])) {
+            krsort($this->listeners[$eventName]);
+            unset($this->unsorted[$eventName]);
+        }
+
+        // Collect listeners and resolve callables if necessary.
+        foreach ($this->listeners[$eventName] as &$definitions) {
+            foreach ($definitions as &$definition) {
+                if (!isset($definition['callable'])) {
+                    $definition['callable'] = array($this->container->get($definition['service']['id']), $definition['service']['method']);
+                }
+
+                $result[] = $definition['callable'];
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasListeners($eventName = null)
+    {
+        return (bool) count($this->getListeners($eventName));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addListener($eventName, $listener, $priority = 0)
+    {
+        $this->listeners[$eventName][$priority][] = array('callable' => $listener);
+        $this->unsorted[$eventName] = true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeListener($eventName, $listener)
+    {
+        if (!isset($this->listeners[$eventName])) {
+            return;
+        }
+
+        foreach ($this->listeners[$eventName] as $priority => $definitions) {
+            foreach ($definitions as $key => $definition) {
+                if (!isset($definition['callable'])) {
+                    if (!$this->container->initialized($definition['service']['id'])) {
+                        continue;
+                    }
+                    $definition['callable'] = array($this->container->get($definition['service']['id']), $definition['service']['method']);
+                }
+
+                if ($definition['callable'] === $listener) {
+                    unset($this->listeners[$eventName][$priority][$key]);
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addSubscriber(EventSubscriberInterface $subscriber)
+    {
+        foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
+            if (is_string($params)) {
+                $this->addListener($eventName, array($subscriber, $params));
+            } elseif (is_string($params[0])) {
+                $this->addListener($eventName, array($subscriber, $params[0]), isset($params[1]) ? $params[1] : 0);
+            } else {
+                foreach ($params as $listener) {
+                    $this->addListener($eventName, array($subscriber, $listener[0]), isset($listener[1]) ? $listener[1] : 0);
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeSubscriber(EventSubscriberInterface $subscriber)
+    {
+        foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
+            if (is_array($params) && is_array($params[0])) {
+                foreach ($params as $listener) {
+                    $this->removeListener($eventName, array($subscriber, $listener[0]));
+                }
+            } else {
+                $this->removeListener($eventName, array($subscriber, is_string($params) ? $params : $params[0]));
+            }
+        }
+    }
+}
diff --git a/src/Symfony/Component/EventDispatcher/DependencyInjection/CompiledRegisterListenersPass.php b/src/Symfony/Component/EventDispatcher/DependencyInjection/CompiledRegisterListenersPass.php
@@ -0,0 +1,141 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * Compiler pass to register tagged services for a compiled event dispatcher.
+ */
+class CompiledRegisterListenersPass implements CompilerPassInterface
+{
+    /**
+     * Service name of the event dispatcher in processed container.
+     *
+     * @var string
+     */
+    private $dispatcherService;
+
+    /**
+     * Tag name used for listeners.
+     *
+     * @var string
+     */
+    private $listenerTag;
+
+    /**
+     * Tag name used for subscribers.
+     *
+     * @var string
+     */
+    private $subscriberTag;
+
+    /**
+     * Constructor.
+     *
+     * @param string $dispatcherService Service name of the event dispatcher in processed container
+     * @param string $listenerTag       Tag name used for listeners
+     * @param string $subscriberTag     Tag name used for subscribers
+     */
+    public function __construct($dispatcherService = 'event_dispatcher', $listenerTag = 'kernel.event_listener', $subscriberTag = 'kernel.event_subscriber')
+    {
+        $this->dispatcherService = $dispatcherService;
+        $this->listenerTag = $listenerTag;
+        $this->subscriberTag = $subscriberTag;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition($this->dispatcherService) && !$container->hasAlias($this->dispatcherService)) {
+            return;
+        }
+
+        $definition = $container->findDefinition($this->dispatcherService);
+
+        $listeners = array();
+
+        foreach ($container->findTaggedServiceIds($this->listenerTag) as $id => $events) {
+            $def = $container->getDefinition($id);
+            if (!$def->isPublic()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event listeners are lazy-loaded.', $id));
+            }
+
+            if ($def->isAbstract()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event listeners are lazy-loaded.', $id));
+            }
+
+            foreach ($events as $event) {
+                $priority = isset($event['priority']) ? $event['priority'] : 0;
+
+                if (!isset($event['event'])) {
+                    throw new \InvalidArgumentException(sprintf('Service "%s" must define the "event" attribute on "%s" tags.', $id, $this->listenerTag));
+                }
+
+                if (!isset($event['method'])) {
+                    $event['method'] = 'on'.preg_replace_callback(array(
+                        '/(?<=\b)[a-z]/i',
+                        '/[^a-z0-9]/i',
+                    ), function ($matches) { return strtoupper($matches[0]); }, $event['event']);
+                    $event['method'] = preg_replace('/[^a-z0-9]/i', '', $event['method']);
+                }
+
+                $listeners[$event['event']][$priority][] = array('service' => array('id' => $id, 'method' => $event['method']));
+            }
+        }
+
+        foreach ($container->findTaggedServiceIds($this->subscriberTag) as $id => $attributes) {
+            $def = $container->getDefinition($id);
+            if (!$def->isPublic()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event subscribers are lazy-loaded.', $id));
+            }
+
+            if ($def->isAbstract()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event subscribers are lazy-loaded.', $id));
+            }
+
+            // We must assume that the class value has been correctly filled, even if the service is created by a factory
+            $class = $container->getParameterBag()->resolveValue($def->getClass());
+
+            $refClass = new \ReflectionClass($class);
+            $interface = 'Symfony\Component\EventDispatcher\EventSubscriberInterface';
+            if (!$refClass->implementsInterface($interface)) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must implement interface "%s".', $id, $interface));
+            }
+
+            // Get all subscribed events.
+            foreach ($class::getSubscribedEvents() as $eventName => $params) {
+                if (is_string($params)) {
+                    $priority = 0;
+                    $listeners[$eventName][$priority][] = array('service' => array('id' => $id, 'method' => $params));
+                } elseif (is_string($params[0])) {
+                    $priority = isset($params[1]) ? $params[1] : 0;
+                    $listeners[$eventName][$priority][] = array('service' => array('id' => $id, 'method' => $params[0]));
+                } else {
+                    foreach ($params as $listener) {
+                        $priority = isset($listener[1]) ? $listener[1] : 0;
+                        $listeners[$eventName][$priority][] = array('service' => array('id' => $id, 'method' => $listener[0]));
+                    }
+                }
+            }
+        }
+
+        foreach (array_keys($listeners) as $eventName) {
+            krsort($listeners[$eventName]);
+        }
+
+        $definition->addArgument($listeners);
+    }
+}