Ajout du FR

Ajout du FR + correction du "functions.php"

vendor/zendframework/zend-eventmanager/src/AbstractListenerAggregate.php

@@ -0,0 +1,33 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Abstract aggregate listener
+ */
+abstract class AbstractListenerAggregate implements ListenerAggregateInterface
+{
+    /**
+     * @var \Zend\Stdlib\CallbackHandler[]
+     */
+    protected $listeners = array();
+
+    /**
+     * {@inheritDoc}
+     */
+    public function detach(EventManagerInterface $events)
+    {
+        foreach ($this->listeners as $index => $callback) {
+            if ($events->detach($callback)) {
+                unset($this->listeners[$index]);
+            }
+        }
+    }
+}

vendor/zendframework/zend-eventmanager/src/Event.php

@@ -0,0 +1,209 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use ArrayAccess;
+
+/**
+ * Representation of an event
+ *
+ * Encapsulates the target context and parameters passed, and provides some
+ * behavior for interacting with the event manager.
+ */
+class Event implements EventInterface
+{
+    /**
+     * @var string Event name
+     */
+    protected $name;
+
+    /**
+     * @var string|object The event target
+     */
+    protected $target;
+
+    /**
+     * @var array|ArrayAccess|object The event parameters
+     */
+    protected $params = array();
+
+    /**
+     * @var bool Whether or not to stop propagation
+     */
+    protected $stopPropagation = false;
+
+    /**
+     * Constructor
+     *
+     * Accept a target and its parameters.
+     *
+     * @param  string $name Event name
+     * @param  string|object $target
+     * @param  array|ArrayAccess $params
+     */
+    public function __construct($name = null, $target = null, $params = null)
+    {
+        if (null !== $name) {
+            $this->setName($name);
+        }
+
+        if (null !== $target) {
+            $this->setTarget($target);
+        }
+
+        if (null !== $params) {
+            $this->setParams($params);
+        }
+    }
+
+    /**
+     * Get event name
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Get the event target
+     *
+     * This may be either an object, or the name of a static method.
+     *
+     * @return string|object
+     */
+    public function getTarget()
+    {
+        return $this->target;
+    }
+
+    /**
+     * Set parameters
+     *
+     * Overwrites parameters
+     *
+     * @param  array|ArrayAccess|object $params
+     * @return Event
+     * @throws Exception\InvalidArgumentException
+     */
+    public function setParams($params)
+    {
+        if (!is_array($params) && !is_object($params)) {
+            throw new Exception\InvalidArgumentException(
+                sprintf('Event parameters must be an array or object; received "%s"', gettype($params))
+            );
+        }
+
+        $this->params = $params;
+        return $this;
+    }
+
+    /**
+     * Get all parameters
+     *
+     * @return array|object|ArrayAccess
+     */
+    public function getParams()
+    {
+        return $this->params;
+    }
+
+    /**
+     * Get an individual parameter
+     *
+     * If the parameter does not exist, the $default value will be returned.
+     *
+     * @param  string|int $name
+     * @param  mixed $default
+     * @return mixed
+     */
+    public function getParam($name, $default = null)
+    {
+        // Check in params that are arrays or implement array access
+        if (is_array($this->params) || $this->params instanceof ArrayAccess) {
+            if (!isset($this->params[$name])) {
+                return $default;
+            }
+
+            return $this->params[$name];
+        }
+
+        // Check in normal objects
+        if (!isset($this->params->{$name})) {
+            return $default;
+        }
+        return $this->params->{$name};
+    }
+
+    /**
+     * Set the event name
+     *
+     * @param  string $name
+     * @return Event
+     */
+    public function setName($name)
+    {
+        $this->name = (string) $name;
+        return $this;
+    }
+
+    /**
+     * Set the event target/context
+     *
+     * @param  null|string|object $target
+     * @return Event
+     */
+    public function setTarget($target)
+    {
+        $this->target = $target;
+        return $this;
+    }
+
+    /**
+     * Set an individual parameter to a value
+     *
+     * @param  string|int $name
+     * @param  mixed $value
+     * @return Event
+     */
+    public function setParam($name, $value)
+    {
+        if (is_array($this->params) || $this->params instanceof ArrayAccess) {
+            // Arrays or objects implementing array access
+            $this->params[$name] = $value;
+        } else {
+            // Objects
+            $this->params->{$name} = $value;
+        }
+        return $this;
+    }
+
+    /**
+     * Stop further event propagation
+     *
+     * @param  bool $flag
+     * @return void
+     */
+    public function stopPropagation($flag = true)
+    {
+        $this->stopPropagation = (bool) $flag;
+    }
+
+    /**
+     * Is propagation stopped?
+     *
+     * @return bool
+     */
+    public function propagationIsStopped()
+    {
+        return $this->stopPropagation;
+    }
+}

vendor/zendframework/zend-eventmanager/src/EventInterface.php

@@ -0,0 +1,96 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use ArrayAccess;
+
+/**
+ * Representation of an event
+ */
+interface EventInterface
+{
+    /**
+     * Get event name
+     *
+     * @return string
+     */
+    public function getName();
+
+    /**
+     * Get target/context from which event was triggered
+     *
+     * @return null|string|object
+     */
+    public function getTarget();
+
+    /**
+     * Get parameters passed to the event
+     *
+     * @return array|ArrayAccess
+     */
+    public function getParams();
+
+    /**
+     * Get a single parameter by name
+     *
+     * @param  string $name
+     * @param  mixed $default Default value to return if parameter does not exist
+     * @return mixed
+     */
+    public function getParam($name, $default = null);
+
+    /**
+     * Set the event name
+     *
+     * @param  string $name
+     * @return void
+     */
+    public function setName($name);
+
+    /**
+     * Set the event target/context
+     *
+     * @param  null|string|object $target
+     * @return void
+     */
+    public function setTarget($target);
+
+    /**
+     * Set event parameters
+     *
+     * @param  string $params
+     * @return void
+     */
+    public function setParams($params);
+
+    /**
+     * Set a single parameter by key
+     *
+     * @param  string $name
+     * @param  mixed $value
+     * @return void
+     */
+    public function setParam($name, $value);
+
+    /**
+     * Indicate whether or not the parent EventManagerInterface should stop propagating events
+     *
+     * @param  bool $flag
+     * @return void
+     */
+    public function stopPropagation($flag = true);
+
+    /**
+     * Has this event indicated event propagation should stop?
+     *
+     * @return bool
+     */
+    public function propagationIsStopped();
+}

vendor/zendframework/zend-eventmanager/src/EventManager.php

@@ -0,0 +1,526 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use ArrayAccess;
+use ArrayObject;
+use Traversable;
+use Zend\Stdlib\CallbackHandler;
+use Zend\Stdlib\PriorityQueue;
+
+/**
+ * Event manager: notification system
+ *
+ * Use the EventManager when you want to create a per-instance notification
+ * system for your objects.
+ */
+class EventManager implements EventManagerInterface
+{
+    /**
+     * Subscribed events and their listeners
+     * @var array Array of PriorityQueue objects
+     */
+    protected $events = array();
+
+    /**
+     * @var string Class representing the event being emitted
+     */
+    protected $eventClass = 'Zend\EventManager\Event';
+
+    /**
+     * Identifiers, used to pull shared signals from SharedEventManagerInterface instance
+     * @var array
+     */
+    protected $identifiers = array();
+
+    /**
+     * Shared event manager
+     * @var false|null|SharedEventManagerInterface
+     */
+    protected $sharedManager = null;
+
+    /**
+     * Constructor
+     *
+     * Allows optionally specifying identifier(s) to use to pull signals from a
+     * SharedEventManagerInterface.
+     *
+     * @param  null|string|int|array|Traversable $identifiers
+     */
+    public function __construct($identifiers = null)
+    {
+        $this->setIdentifiers($identifiers);
+    }
+
+    /**
+     * Set the event class to utilize
+     *
+     * @param  string $class
+     * @return EventManager
+     */
+    public function setEventClass($class)
+    {
+        $this->eventClass = $class;
+        return $this;
+    }
+
+    /**
+     * Set shared event manager
+     *
+     * @param SharedEventManagerInterface $sharedEventManager
+     * @return EventManager
+     */
+    public function setSharedManager(SharedEventManagerInterface $sharedEventManager)
+    {
+        $this->sharedManager = $sharedEventManager;
+        StaticEventManager::setInstance($sharedEventManager);
+        return $this;
+    }
+
+    /**
+     * Remove any shared event manager currently attached
+     *
+     * @return void
+     */
+    public function unsetSharedManager()
+    {
+        $this->sharedManager = false;
+    }
+
+    /**
+     * Get shared event manager
+     *
+     * If one is not defined, but we have a static instance in
+     * StaticEventManager, that one will be used and set in this instance.
+     *
+     * If none is available in the StaticEventManager, a boolean false is
+     * returned.
+     *
+     * @return false|SharedEventManagerInterface
+     */
+    public function getSharedManager()
+    {
+        // "false" means "I do not want a shared manager; don't try and fetch one"
+        if (false === $this->sharedManager
+            || $this->sharedManager instanceof SharedEventManagerInterface
+        ) {
+            return $this->sharedManager;
+        }
+
+        if (!StaticEventManager::hasInstance()) {
+            return false;
+        }
+
+        $this->sharedManager = StaticEventManager::getInstance();
+        return $this->sharedManager;
+    }
+
+    /**
+     * Get the identifier(s) for this EventManager
+     *
+     * @return array
+     */
+    public function getIdentifiers()
+    {
+        return $this->identifiers;
+    }
+
+    /**
+     * Set the identifiers (overrides any currently set identifiers)
+     *
+     * @param string|int|array|Traversable $identifiers
+     * @return EventManager Provides a fluent interface
+     */
+    public function setIdentifiers($identifiers)
+    {
+        if (is_array($identifiers) || $identifiers instanceof Traversable) {
+            $this->identifiers = array_unique((array) $identifiers);
+        } elseif ($identifiers !== null) {
+            $this->identifiers = array($identifiers);
+        }
+        return $this;
+    }
+
+    /**
+     * Add some identifier(s) (appends to any currently set identifiers)
+     *
+     * @param string|int|array|Traversable $identifiers
+     * @return EventManager Provides a fluent interface
+     */
+    public function addIdentifiers($identifiers)
+    {
+        if (is_array($identifiers) || $identifiers instanceof Traversable) {
+            $this->identifiers = array_unique(array_merge($this->identifiers, (array) $identifiers));
+        } elseif ($identifiers !== null) {
+            $this->identifiers = array_unique(array_merge($this->identifiers, array($identifiers)));
+        }
+        return $this;
+    }
+
+    /**
+     * Trigger all listeners for a given event
+     *
+     * @param  string|EventInterface $event
+     * @param  string|object     $target   Object calling emit, or symbol describing target (such as static method name)
+     * @param  array|ArrayAccess $argv     Array of arguments; typically, should be associative
+     * @param  null|callable     $callback Trigger listeners until return value of this callback evaluate to true
+     * @return ResponseCollection All listener return values
+     * @throws Exception\InvalidCallbackException
+     */
+    public function trigger($event, $target = null, $argv = array(), $callback = null)
+    {
+        if ($event instanceof EventInterface) {
+            $e        = $event;
+            $event    = $e->getName();
+            $callback = $target;
+        } elseif ($target instanceof EventInterface) {
+            $e = $target;
+            $e->setName($event);
+            $callback = $argv;
+        } elseif ($argv instanceof EventInterface) {
+            $e = $argv;
+            $e->setName($event);
+            $e->setTarget($target);
+        } else {
+            $e = new $this->eventClass();
+            $e->setName($event);
+            $e->setTarget($target);
+            $e->setParams($argv);
+        }
+
+        if ($callback && !is_callable($callback)) {
+            throw new Exception\InvalidCallbackException('Invalid callback provided');
+        }
+
+        // Initial value of stop propagation flag should be false
+        $e->stopPropagation(false);
+
+        return $this->triggerListeners($event, $e, $callback);
+    }
+
+    /**
+     * Trigger listeners until return value of one causes a callback to
+     * evaluate to true
+     *
+     * Triggers listeners until the provided callback evaluates the return
+     * value of one as true, or until all listeners have been executed.
+     *
+     * @param  string|EventInterface $event
+     * @param  string|object $target Object calling emit, or symbol describing target (such as static method name)
+     * @param  array|ArrayAccess $argv Array of arguments; typically, should be associative
+     * @param  callable $callback
+     * @return ResponseCollection
+     * @deprecated Please use trigger()
+     * @throws Exception\InvalidCallbackException if invalid callable provided
+     */
+    public function triggerUntil($event, $target, $argv = null, $callback = null)
+    {
+        trigger_error(
+            'This method is deprecated and will be removed in the future. Please use trigger() instead.',
+            E_USER_DEPRECATED
+        );
+        return $this->trigger($event, $target, $argv, $callback);
+    }
+
+    /**
+     * Attach a listener to an event
+     *
+     * The first argument is the event, and the next argument describes a
+     * callback that will respond to that event. A CallbackHandler instance
+     * describing the event listener combination will be returned.
+     *
+     * The last argument indicates a priority at which the event should be
+     * executed. By default, this value is 1; however, you may set it for any
+     * integer value. Higher values have higher priority (i.e., execute first).
+     *
+     * You can specify "*" for the event name. In such cases, the listener will
+     * be triggered for every event.
+     *
+     * @param  string|array|ListenerAggregateInterface $event An event or array of event names. If a ListenerAggregateInterface, proxies to {@link attachAggregate()}.
+     * @param  callable|int $callback If string $event provided, expects PHP callback; for a ListenerAggregateInterface $event, this will be the priority
+     * @param  int $priority If provided, the priority at which to register the callable
+     * @return CallbackHandler|mixed CallbackHandler if attaching callable (to allow later unsubscribe); mixed if attaching aggregate
+     * @throws Exception\InvalidArgumentException
+     */
+    public function attach($event, $callback = null, $priority = 1)
+    {
+        // Proxy ListenerAggregateInterface arguments to attachAggregate()
+        if ($event instanceof ListenerAggregateInterface) {
+            return $this->attachAggregate($event, $callback);
+        }
+
+        // Null callback is invalid
+        if (null === $callback) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s: expects a callback; none provided',
+                __METHOD__
+            ));
+        }
+
+        // Array of events should be registered individually, and return an array of all listeners
+        if (is_array($event)) {
+            $listeners = array();
+            foreach ($event as $name) {
+                $listeners[] = $this->attach($name, $callback, $priority);
+            }
+            return $listeners;
+        }
+
+        // If we don't have a priority queue for the event yet, create one
+        if (empty($this->events[$event])) {
+            $this->events[$event] = new PriorityQueue();
+        }
+
+        // Create a callback handler, setting the event and priority in its metadata
+        $listener = new CallbackHandler($callback, array('event' => $event, 'priority' => $priority));
+
+        // Inject the callback handler into the queue
+        $this->events[$event]->insert($listener, $priority);
+        return $listener;
+    }
+
+    /**
+     * Attach a listener aggregate
+     *
+     * Listener aggregates accept an EventManagerInterface instance, and call attach()
+     * one or more times, typically to attach to multiple events using local
+     * methods.
+     *
+     * @param  ListenerAggregateInterface $aggregate
+     * @param  int $priority If provided, a suggested priority for the aggregate to use
+     * @return mixed return value of {@link ListenerAggregateInterface::attach()}
+     */
+    public function attachAggregate(ListenerAggregateInterface $aggregate, $priority = 1)
+    {
+        return $aggregate->attach($this, $priority);
+    }
+
+    /**
+     * Unsubscribe a listener from an event
+     *
+     * @param  CallbackHandler|ListenerAggregateInterface $listener
+     * @return bool Returns true if event and listener found, and unsubscribed; returns false if either event or listener not found
+     * @throws Exception\InvalidArgumentException if invalid listener provided
+     */
+    public function detach($listener)
+    {
+        if ($listener instanceof ListenerAggregateInterface) {
+            return $this->detachAggregate($listener);
+        }
+
+        if (!$listener instanceof CallbackHandler) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s: expected a ListenerAggregateInterface or CallbackHandler; received "%s"',
+                __METHOD__,
+                (is_object($listener) ? get_class($listener) : gettype($listener))
+            ));
+        }
+
+        $event = $listener->getMetadatum('event');
+        if (!$event || empty($this->events[$event])) {
+            return false;
+        }
+        $return = $this->events[$event]->remove($listener);
+        if (!$return) {
+            return false;
+        }
+        if (!count($this->events[$event])) {
+            unset($this->events[$event]);
+        }
+        return true;
+    }
+
+    /**
+     * Detach a listener aggregate
+     *
+     * Listener aggregates accept an EventManagerInterface instance, and call detach()
+     * of all previously attached listeners.
+     *
+     * @param  ListenerAggregateInterface $aggregate
+     * @return mixed return value of {@link ListenerAggregateInterface::detach()}
+     */
+    public function detachAggregate(ListenerAggregateInterface $aggregate)
+    {
+        return $aggregate->detach($this);
+    }
+
+    /**
+     * Retrieve all registered events
+     *
+     * @return array
+     */
+    public function getEvents()
+    {
+        return array_keys($this->events);
+    }
+
+    /**
+     * Retrieve all listeners for a given event
+     *
+     * @param  string $event
+     * @return PriorityQueue
+     */
+    public function getListeners($event)
+    {
+        if (!array_key_exists($event, $this->events)) {
+            return new PriorityQueue();
+        }
+        return $this->events[$event];
+    }
+
+    /**
+     * Clear all listeners for a given event
+     *
+     * @param  string $event
+     * @return void
+     */
+    public function clearListeners($event)
+    {
+        if (!empty($this->events[$event])) {
+            unset($this->events[$event]);
+        }
+    }
+
+    /**
+     * Prepare arguments
+     *
+     * Use this method if you want to be able to modify arguments from within a
+     * listener. It returns an ArrayObject of the arguments, which may then be
+     * passed to trigger().
+     *
+     * @param  array $args
+     * @return ArrayObject
+     */
+    public function prepareArgs(array $args)
+    {
+        return new ArrayObject($args);
+    }
+
+    /**
+     * Trigger listeners
+     *
+     * Actual functionality for triggering listeners, to which trigger() delegate.
+     *
+     * @param  string           $event Event name
+     * @param  EventInterface $e
+     * @param  null|callable    $callback
+     * @return ResponseCollection
+     */
+    protected function triggerListeners($event, EventInterface $e, $callback = null)
+    {
+        $responses = new ResponseCollection;
+        $listeners = $this->getListeners($event);
+
+        // Add shared/wildcard listeners to the list of listeners,
+        // but don't modify the listeners object
+        $sharedListeners         = $this->getSharedListeners($event);
+        $sharedWildcardListeners = $this->getSharedListeners('*');
+        $wildcardListeners       = $this->getListeners('*');
+        if (count($sharedListeners) || count($sharedWildcardListeners) || count($wildcardListeners)) {
+            $listeners = clone $listeners;
+
+            // Shared listeners on this specific event
+            $this->insertListeners($listeners, $sharedListeners);
+
+            // Shared wildcard listeners
+            $this->insertListeners($listeners, $sharedWildcardListeners);
+
+            // Add wildcard listeners
+            $this->insertListeners($listeners, $wildcardListeners);
+        }
+
+        foreach ($listeners as $listener) {
+            $listenerCallback = $listener->getCallback();
+
+            // Trigger the listener's callback, and push its result onto the
+            // response collection
+            $responses->push(call_user_func($listenerCallback, $e));
+
+            // If the event was asked to stop propagating, do so
+            if ($e->propagationIsStopped()) {
+                $responses->setStopped(true);
+                break;
+            }
+
+            // If the result causes our validation callback to return true,
+            // stop propagation
+            if ($callback && call_user_func($callback, $responses->last())) {
+                $responses->setStopped(true);
+                break;
+            }
+        }
+
+        return $responses;
+    }
+
+    /**
+     * Get list of all listeners attached to the shared event manager for
+     * identifiers registered by this instance
+     *
+     * @param  string $event
+     * @return array
+     */
+    protected function getSharedListeners($event)
+    {
+        if (!$sharedManager = $this->getSharedManager()) {
+            return array();
+        }
+
+        $identifiers     = $this->getIdentifiers();
+        //Add wildcard id to the search, if not already added
+        if (!in_array('*', $identifiers)) {
+            $identifiers[] = '*';
+        }
+        $sharedListeners = array();
+
+        foreach ($identifiers as $id) {
+            if (!$listeners = $sharedManager->getListeners($id, $event)) {
+                continue;
+            }
+
+            if (!is_array($listeners) && !($listeners instanceof Traversable)) {
+                continue;
+            }
+
+            foreach ($listeners as $listener) {
+                if (!$listener instanceof CallbackHandler) {
+                    continue;
+                }
+                $sharedListeners[] = $listener;
+            }
+        }
+
+        return $sharedListeners;
+    }
+
+    /**
+     * Add listeners to the master queue of listeners
+     *
+     * Used to inject shared listeners and wildcard listeners.
+     *
+     * @param  PriorityQueue $masterListeners
+     * @param  array|Traversable $listeners
+     * @return void
+     */
+    protected function insertListeners($masterListeners, $listeners)
+    {
+        foreach ($listeners as $listener) {
+            $priority = $listener->getMetadatum('priority');
+            if (null === $priority) {
+                $priority = 1;
+            } elseif (is_array($priority)) {
+                // If we have an array, likely using PriorityQueue. Grab first
+                // element of the array, as that's the actual priority.
+                $priority = array_shift($priority);
+            }
+            $masterListeners->insert($listener, $priority);
+        }
+    }
+}

vendor/zendframework/zend-eventmanager/src/EventManagerAwareInterface.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface to automate setter injection for an EventManager instance
+ */
+interface EventManagerAwareInterface extends EventsCapableInterface
+{
+    /**
+     * Inject an EventManager instance
+     *
+     * @param  EventManagerInterface $eventManager
+     * @return void
+     */
+    public function setEventManager(EventManagerInterface $eventManager);
+}

vendor/zendframework/zend-eventmanager/src/EventManagerAwareTrait.php

@@ -0,0 +1,77 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use Traversable;
+
+/**
+ * A trait for objects that provide events.
+ *
+ * If you use this trait in an object, you will probably want to also implement
+ * EventManagerAwareInterface, which will make it so the default initializer in
+ * a ZF2 MVC application will automatically inject an instance of the
+ * EventManager into your object when it is pulled from the ServiceManager.
+ *
+ * @see Zend\Mvc\Service\ServiceManagerConfig
+ */
+trait EventManagerAwareTrait
+{
+    /**
+     * @var EventManagerInterface
+     */
+    protected $events;
+
+    /**
+     * Set the event manager instance used by this context.
+     *
+     * For convenience, this method will also set the class name / LSB name as
+     * identifiers, in addition to any string or array of strings set to the
+     * $this->eventIdentifier property.
+     *
+     * @param  EventManagerInterface $events
+     * @return mixed
+     */
+    public function setEventManager(EventManagerInterface $events)
+    {
+        $identifiers = array(__CLASS__, get_class($this));
+        if (isset($this->eventIdentifier)) {
+            if ((is_string($this->eventIdentifier))
+                || (is_array($this->eventIdentifier))
+                || ($this->eventIdentifier instanceof Traversable)
+            ) {
+                $identifiers = array_unique(array_merge($identifiers, (array) $this->eventIdentifier));
+            } elseif (is_object($this->eventIdentifier)) {
+                $identifiers[] = $this->eventIdentifier;
+            }
+            // silently ignore invalid eventIdentifier types
+        }
+        $events->setIdentifiers($identifiers);
+        $this->events = $events;
+        if (method_exists($this, 'attachDefaultListeners')) {
+            $this->attachDefaultListeners();
+        }
+        return $this;
+    }
+
+    /**
+     * Retrieve the event manager
+     *
+     * Lazy-loads an EventManager instance if none registered.
+     *
+     * @return EventManagerInterface
+     */
+    public function getEventManager()
+    {
+        if (!$this->events instanceof EventManagerInterface) {
+            $this->setEventManager(new EventManager());
+        }
+        return $this->events;
+    }
+}

vendor/zendframework/zend-eventmanager/src/EventManagerInterface.php

@@ -0,0 +1,144 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use Traversable;
+use Zend\Stdlib\CallbackHandler;
+
+/**
+ * Interface for messengers
+ */
+interface EventManagerInterface extends SharedEventManagerAwareInterface
+{
+    /**
+     * Trigger an event
+     *
+     * Should allow handling the following scenarios:
+     * - Passing Event object only
+     * - Passing event name and Event object only
+     * - Passing event name, target, and Event object
+     * - Passing event name, target, and array|ArrayAccess of arguments
+     * - Passing event name, target, array|ArrayAccess of arguments, and callback
+     *
+     * @param  string|EventInterface $event
+     * @param  object|string $target
+     * @param  array|object $argv
+     * @param  null|callable $callback
+     * @return ResponseCollection
+     */
+    public function trigger($event, $target = null, $argv = array(), $callback = null);
+
+    /**
+     * Trigger an event until the given callback returns a boolean true
+     *
+     * Should allow handling the following scenarios:
+     * - Passing Event object and callback only
+     * - Passing event name, Event object, and callback only
+     * - Passing event name, target, Event object, and callback
+     * - Passing event name, target, array|ArrayAccess of arguments, and callback
+     *
+     * @param  string|EventInterface $event
+     * @param  object|string $target
+     * @param  array|object $argv
+     * @param  callable $callback
+     * @return ResponseCollection
+     * @deprecated Please use trigger()
+     */
+    public function triggerUntil($event, $target, $argv = null, $callback = null);
+
+    /**
+     * Attach a listener to an event
+     *
+     * @param  string $event
+     * @param  callable $callback
+     * @param  int $priority Priority at which to register listener
+     * @return CallbackHandler
+     */
+    public function attach($event, $callback = null, $priority = 1);
+
+    /**
+     * Detach an event listener
+     *
+     * @param  CallbackHandler|ListenerAggregateInterface $listener
+     * @return bool
+     */
+    public function detach($listener);
+
+    /**
+     * Get a list of events for which this collection has listeners
+     *
+     * @return array
+     */
+    public function getEvents();
+
+    /**
+     * Retrieve a list of listeners registered to a given event
+     *
+     * @param  string $event
+     * @return array|object
+     */
+    public function getListeners($event);
+
+    /**
+     * Clear all listeners for a given event
+     *
+     * @param  string $event
+     * @return void
+     */
+    public function clearListeners($event);
+
+    /**
+     * Set the event class to utilize
+     *
+     * @param  string $class
+     * @return EventManagerInterface
+     */
+    public function setEventClass($class);
+
+    /**
+     * Get the identifier(s) for this EventManager
+     *
+     * @return array
+     */
+    public function getIdentifiers();
+
+    /**
+     * Set the identifiers (overrides any currently set identifiers)
+     *
+     * @param string|int|array|Traversable $identifiers
+     * @return EventManagerInterface
+     */
+    public function setIdentifiers($identifiers);
+
+    /**
+     * Add some identifier(s) (appends to any currently set identifiers)
+     *
+     * @param string|int|array|Traversable $identifiers
+     * @return EventManagerInterface
+     */
+    public function addIdentifiers($identifiers);
+
+    /**
+     * Attach a listener aggregate
+     *
+     * @param  ListenerAggregateInterface $aggregate
+     * @param  int $priority If provided, a suggested priority for the aggregate to use
+     * @return mixed return value of {@link ListenerAggregateInterface::attach()}
+     */
+    public function attachAggregate(ListenerAggregateInterface $aggregate, $priority = 1);
+
+    /**
+     * Detach a listener aggregate
+     *
+     * @param  ListenerAggregateInterface $aggregate
+     * @return mixed return value of {@link ListenerAggregateInterface::detach()}
+     */
+    public function detachAggregate(ListenerAggregateInterface $aggregate);
+}

vendor/zendframework/zend-eventmanager/src/EventsCapableInterface.php

@@ -0,0 +1,25 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface providing events that can be attached, detached and triggered.
+ */
+interface EventsCapableInterface
+{
+    /**
+     * Retrieve the event manager
+     *
+     * Lazy-loads an EventManager instance if none registered.
+     *
+     * @return EventManagerInterface
+     */
+    public function getEventManager();
+}

vendor/zendframework/zend-eventmanager/src/Exception/DomainException.php

@@ -0,0 +1,14 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager\Exception;
+
+class DomainException extends \DomainException implements ExceptionInterface
+{
+}

vendor/zendframework/zend-eventmanager/src/Exception/ExceptionInterface.php

@@ -0,0 +1,17 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager\Exception;
+
+/**
+ * Base exception interface
+ */
+interface ExceptionInterface
+{
+}

vendor/zendframework/zend-eventmanager/src/Exception/InvalidArgumentException.php

@@ -0,0 +1,17 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager\Exception;
+
+/**
+ * Invalid argument exception
+ */
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+{
+}

vendor/zendframework/zend-eventmanager/src/Exception/InvalidCallbackException.php

@@ -0,0 +1,17 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager\Exception;
+
+/**
+ * Invalid callback exception
+ */
+class InvalidCallbackException extends DomainException implements ExceptionInterface
+{
+}

vendor/zendframework/zend-eventmanager/src/Filter/FilterInterface.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager\Filter;
+
+use Zend\EventManager\ResponseCollection;
+use Zend\Stdlib\CallbackHandler;
+
+/**
+ * Interface for intercepting filter chains
+ */
+interface FilterInterface
+{
+    /**
+     * Execute the filter chain
+     *
+     * @param  string|object $context
+     * @param  array $params
+     * @return mixed
+     */
+    public function run($context, array $params = array());
+
+    /**
+     * Attach an intercepting filter
+     *
+     * @param  callable $callback
+     * @return CallbackHandler
+     */
+    public function attach($callback);
+
+    /**
+     * Detach an intercepting filter
+     *
+     * @param  CallbackHandler $filter
+     * @return bool
+     */
+    public function detach(CallbackHandler $filter);
+
+    /**
+     * Get all intercepting filters
+     *
+     * @return array
+     */
+    public function getFilters();
+
+    /**
+     * Clear all filters
+     *
+     * @return void
+     */
+    public function clearFilters();
+
+    /**
+     * Get all filter responses
+     *
+     * @return ResponseCollection
+     */
+    public function getResponses();
+}

vendor/zendframework/zend-eventmanager/src/Filter/FilterIterator.php

@@ -0,0 +1,99 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager\Filter;
+
+use Zend\Stdlib\CallbackHandler;
+use Zend\Stdlib\SplPriorityQueue;
+
+/**
+ * Specialized priority queue implementation for use with an intercepting
+ * filter chain.
+ *
+ * Allows removal
+ */
+class FilterIterator extends SplPriorityQueue
+{
+    /**
+     * Does the queue contain a given value?
+     *
+     * @param  mixed $datum
+     * @return bool
+     */
+    public function contains($datum)
+    {
+        $chain = clone $this;
+        foreach ($chain as $item) {
+            if ($item === $datum) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Remove a value from the queue
+     *
+     * This is an expensive operation. It must first iterate through all values,
+     * and then re-populate itself. Use only if absolutely necessary.
+     *
+     * @param  mixed $datum
+     * @return bool
+     */
+    public function remove($datum)
+    {
+        $this->setExtractFlags(self::EXTR_BOTH);
+
+        // Iterate and remove any matches
+        $removed = false;
+        $items   = array();
+        $this->rewind();
+        while (!$this->isEmpty()) {
+            $item = $this->extract();
+            if ($item['data'] === $datum) {
+                $removed = true;
+                continue;
+            }
+            $items[] = $item;
+        }
+
+        // Repopulate
+        foreach ($items as $item) {
+            $this->insert($item['data'], $item['priority']);
+        }
+
+        $this->setExtractFlags(self::EXTR_DATA);
+        return $removed;
+    }
+
+    /**
+     * Iterate the next filter in the chain
+     *
+     * Iterates and calls the next filter in the chain.
+     *
+     * @param  mixed $context
+     * @param  array $params
+     * @param  FilterIterator $chain
+     * @return mixed
+     */
+    public function next($context = null, array $params = array(), $chain = null)
+    {
+        if (empty($context) || $chain->isEmpty()) {
+            return;
+        }
+
+        $next = $this->extract();
+        if (!$next instanceof CallbackHandler) {
+            return;
+        }
+
+        $return = call_user_func($next->getCallback(), $context, $params, $chain);
+        return $return;
+    }
+}

vendor/zendframework/zend-eventmanager/src/FilterChain.php

@@ -0,0 +1,120 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use Zend\Stdlib\CallbackHandler;
+
+/**
+ * FilterChain: intercepting filter manager
+ */
+class FilterChain implements Filter\FilterInterface
+{
+    /**
+     * @var Filter\FilterIterator All filters
+     */
+    protected $filters;
+
+    /**
+     * Constructor
+     *
+     * Initializes Filter\FilterIterator in which filters will be aggregated
+     */
+    public function __construct()
+    {
+        $this->filters = new Filter\FilterIterator();
+    }
+
+    /**
+     * Apply the filters
+     *
+     * Begins iteration of the filters.
+     *
+     * @param  mixed $context Object under observation
+     * @param  mixed $argv Associative array of arguments
+     * @return mixed
+     */
+    public function run($context, array $argv = array())
+    {
+        $chain = clone $this->getFilters();
+
+        if ($chain->isEmpty()) {
+            return;
+        }
+
+        $next = $chain->extract();
+        if (!$next instanceof CallbackHandler) {
+            return;
+        }
+
+        return call_user_func($next->getCallback(), $context, $argv, $chain);
+    }
+
+    /**
+     * Connect a filter to the chain
+     *
+     * @param  callable $callback PHP Callback
+     * @param  int $priority Priority in the queue at which to execute; defaults to 1 (higher numbers == higher priority)
+     * @return CallbackHandler (to allow later unsubscribe)
+     * @throws Exception\InvalidCallbackException
+     */
+    public function attach($callback, $priority = 1)
+    {
+        if (empty($callback)) {
+            throw new Exception\InvalidCallbackException('No callback provided');
+        }
+        $filter = new CallbackHandler($callback, array('priority' => $priority));
+        $this->filters->insert($filter, $priority);
+        return $filter;
+    }
+
+    /**
+     * Detach a filter from the chain
+     *
+     * @param  CallbackHandler $filter
+     * @return bool Returns true if filter found and unsubscribed; returns false otherwise
+     */
+    public function detach(CallbackHandler $filter)
+    {
+        return $this->filters->remove($filter);
+    }
+
+    /**
+     * Retrieve all filters
+     *
+     * @return Filter\FilterIterator
+     */
+    public function getFilters()
+    {
+        return $this->filters;
+    }
+
+    /**
+     * Clear all filters
+     *
+     * @return void
+     */
+    public function clearFilters()
+    {
+        $this->filters = new Filter\FilterIterator();
+    }
+
+    /**
+     * Return current responses
+     *
+     * Only available while the chain is still being iterated. Returns the
+     * current ResponseCollection.
+     *
+     * @return null|ResponseCollection
+     */
+    public function getResponses()
+    {
+        return;
+    }
+}

vendor/zendframework/zend-eventmanager/src/GlobalEventManager.php

@@ -0,0 +1,141 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use Zend\Stdlib\CallbackHandler;
+use Zend\Stdlib\PriorityQueue;
+
+/**
+ * Event manager: notification system
+ *
+ * Use the EventManager when you want to create a per-instance notification
+ * system for your objects.
+ */
+class GlobalEventManager
+{
+    /**
+     * @var EventManagerInterface
+     */
+    protected static $events;
+
+    /**
+     * Set the event collection on which this will operate
+     *
+     * @param  null|EventManagerInterface $events
+     * @return void
+     */
+    public static function setEventCollection(EventManagerInterface $events = null)
+    {
+        static::$events = $events;
+    }
+
+    /**
+     * Get event collection on which this operates
+     *
+     * @return EventManagerInterface
+     */
+    public static function getEventCollection()
+    {
+        if (null === static::$events) {
+            static::setEventCollection(new EventManager());
+        }
+        return static::$events;
+    }
+
+    /**
+     * Trigger an event
+     *
+     * @param  string        $event
+     * @param  object|string $context
+     * @param  array|object  $argv
+     * @param  null|callable $callback
+     * @return ResponseCollection
+     */
+    public static function trigger($event, $context, $argv = array(), $callback = null)
+    {
+        return static::getEventCollection()->trigger($event, $context, $argv, $callback);
+    }
+
+    /**
+     * Trigger listeners until return value of one causes a callback to evaluate
+     * to true.
+     *
+     * @param  string $event
+     * @param  string|object $context
+     * @param  array|object $argv
+     * @param  callable $callback
+     * @return ResponseCollection
+     * @deprecated Please use trigger()
+     */
+    public static function triggerUntil($event, $context, $argv, $callback)
+    {
+        trigger_error(
+            'This method is deprecated and will be removed in the future. Please use trigger() instead.',
+            E_USER_DEPRECATED
+        );
+        return static::trigger($event, $context, $argv, $callback);
+    }
+
+    /**
+     * Attach a listener to an event
+     *
+     * @param  string $event
+     * @param  callable $callback
+     * @param  int $priority
+     * @return CallbackHandler
+     */
+    public static function attach($event, $callback, $priority = 1)
+    {
+        return static::getEventCollection()->attach($event, $callback, $priority);
+    }
+
+    /**
+     * Detach a callback from a listener
+     *
+     * @param  CallbackHandler $listener
+     * @return bool
+     */
+    public static function detach(CallbackHandler $listener)
+    {
+        return static::getEventCollection()->detach($listener);
+    }
+
+    /**
+     * Retrieve list of events this object manages
+     *
+     * @return array
+     */
+    public static function getEvents()
+    {
+        return static::getEventCollection()->getEvents();
+    }
+
+    /**
+     * Retrieve all listeners for a given event
+     *
+     * @param  string $event
+     * @return PriorityQueue|array
+     */
+    public static function getListeners($event)
+    {
+        return static::getEventCollection()->getListeners($event);
+    }
+
+    /**
+     * Clear all listeners for a given event
+     *
+     * @param  string $event
+     * @return void
+     */
+    public static function clearListeners($event)
+    {
+        static::getEventCollection()->clearListeners($event);
+    }
+}

vendor/zendframework/zend-eventmanager/src/ListenerAggregateInterface.php

@@ -0,0 +1,42 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface for self-registering event listeners.
+ *
+ * Classes implementing this interface may be registered by name or instance
+ * with an EventManager, without an event name. The {@link attach()} method will
+ * then be called with the current EventManager instance, allowing the class to
+ * wire up one or more listeners.
+ */
+interface ListenerAggregateInterface
+{
+    /**
+     * Attach one or more listeners
+     *
+     * Implementors may add an optional $priority argument; the EventManager
+     * implementation will pass this to the aggregate.
+     *
+     * @param EventManagerInterface $events
+     *
+     * @return void
+     */
+    public function attach(EventManagerInterface $events);
+
+    /**
+     * Detach all previously attached listeners
+     *
+     * @param EventManagerInterface $events
+     *
+     * @return void
+     */
+    public function detach(EventManagerInterface $events);
+}

vendor/zendframework/zend-eventmanager/src/ListenerAggregateTrait.php

@@ -0,0 +1,34 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Provides logic to easily create aggregate listeners, without worrying about
+ * manually detaching events
+ */
+trait ListenerAggregateTrait
+{
+    /**
+     * @var \Zend\Stdlib\CallbackHandler[]
+     */
+    protected $listeners = array();
+
+    /**
+     * {@inheritDoc}
+     */
+    public function detach(EventManagerInterface $events)
+    {
+        foreach ($this->listeners as $index => $callback) {
+            if ($events->detach($callback)) {
+                unset($this->listeners[$index]);
+            }
+        }
+    }
+}

vendor/zendframework/zend-eventmanager/src/ProvidesEvents.php

@@ -0,0 +1,23 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+trigger_error('Zend\EventManager\ProvidesEvents has been deprecated in favor of Zend\EventManager\EventManagerAwareTrait; please update your code', E_USER_DEPRECATED);
+
+/**
+ * @deprecated Please use EventManagerAwareTrait instead.
+ *
+ * This trait exists solely for backwards compatibility in the 2.x branch and
+ * will likely be removed in 3.x.
+ */
+trait ProvidesEvents
+{
+    use EventManagerAwareTrait;
+}

vendor/zendframework/zend-eventmanager/src/ResponseCollection.php

@@ -0,0 +1,84 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use SplStack;
+
+/**
+ * Collection of signal handler return values
+ */
+class ResponseCollection extends SplStack
+{
+    protected $stopped = false;
+
+    /**
+     * Did the last response provided trigger a short circuit of the stack?
+     *
+     * @return bool
+     */
+    public function stopped()
+    {
+        return $this->stopped;
+    }
+
+    /**
+     * Mark the collection as stopped (or its opposite)
+     *
+     * @param  bool $flag
+     * @return ResponseCollection
+     */
+    public function setStopped($flag)
+    {
+        $this->stopped = (bool) $flag;
+        return $this;
+    }
+
+    /**
+     * Convenient access to the first handler return value.
+     *
+     * @return mixed The first handler return value
+     */
+    public function first()
+    {
+        return parent::bottom();
+    }
+
+    /**
+     * Convenient access to the last handler return value.
+     *
+     * If the collection is empty, returns null. Otherwise, returns value
+     * returned by last handler.
+     *
+     * @return mixed The last handler return value
+     */
+    public function last()
+    {
+        if (count($this) === 0) {
+            return;
+        }
+        return parent::top();
+    }
+
+    /**
+     * Check if any of the responses match the given value.
+     *
+     * @param  mixed $value The value to look for among responses
+     * @return bool
+     */
+    public function contains($value)
+    {
+        foreach ($this as $response) {
+            if ($response === $value) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

vendor/zendframework/zend-eventmanager/src/SharedEventAggregateAwareInterface.php

@@ -0,0 +1,33 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface for allowing attachment of shared aggregate listeners.
+ */
+interface SharedEventAggregateAwareInterface
+{
+    /**
+     * Attach a listener aggregate
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @param  int $priority If provided, a suggested priority for the aggregate to use
+     * @return mixed return value of {@link SharedListenerAggregateInterface::attachShared()}
+     */
+    public function attachAggregate(SharedListenerAggregateInterface $aggregate, $priority = 1);
+
+    /**
+     * Detach a listener aggregate
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @return mixed return value of {@link SharedListenerAggregateInterface::detachShared()}
+    */
+    public function detachAggregate(SharedListenerAggregateInterface $aggregate);
+}

vendor/zendframework/zend-eventmanager/src/SharedEventManager.php

@@ -0,0 +1,176 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use Zend\Stdlib\CallbackHandler;
+use Zend\Stdlib\PriorityQueue;
+
+/**
+ * Shared/contextual EventManager
+ *
+ * Allows attaching to EMs composed by other classes without having an instance first.
+ * The assumption is that the SharedEventManager will be injected into EventManager
+ * instances, and then queried for additional listeners when triggering an event.
+ */
+class SharedEventManager implements
+    SharedEventAggregateAwareInterface,
+    SharedEventManagerInterface
+{
+    /**
+     * Identifiers with event connections
+     * @var array
+     */
+    protected $identifiers = array();
+
+    /**
+     * Attach a listener to an event
+     *
+     * Allows attaching a callback to an event offered by one or more
+     * identifying components. As an example, the following connects to the
+     * "getAll" event of both an AbstractResource and EntityResource:
+     *
+     * <code>
+     * $sharedEventManager = new SharedEventManager();
+     * $sharedEventManager->attach(
+     *     array('My\Resource\AbstractResource', 'My\Resource\EntityResource'),
+     *     'getAll',
+     *     function ($e) use ($cache) {
+     *         if (!$id = $e->getParam('id', false)) {
+     *             return;
+     *         }
+     *         if (!$data = $cache->load(get_class($resource) . '::getOne::' . $id )) {
+     *             return;
+     *         }
+     *         return $data;
+     *     }
+     * );
+     * </code>
+     *
+     * @param  string|array $id Identifier(s) for event emitting component(s)
+     * @param  string $event
+     * @param  callable $callback PHP Callback
+     * @param  int $priority Priority at which listener should execute
+     * @return CallbackHandler|array Either CallbackHandler or array of CallbackHandlers
+     */
+    public function attach($id, $event, $callback, $priority = 1)
+    {
+        $ids = (array) $id;
+        $listeners = array();
+        foreach ($ids as $id) {
+            if (!array_key_exists($id, $this->identifiers)) {
+                $this->identifiers[$id] = new EventManager($id);
+            }
+            $listeners[] = $this->identifiers[$id]->attach($event, $callback, $priority);
+        }
+        if (count($listeners) > 1) {
+            return $listeners;
+        }
+        return $listeners[0];
+    }
+
+    /**
+     * Attach a listener aggregate
+     *
+     * Listener aggregates accept an EventManagerInterface instance, and call attachShared()
+     * one or more times, typically to attach to multiple events using local
+     * methods.
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @param  int $priority If provided, a suggested priority for the aggregate to use
+     * @return mixed return value of {@link ListenerAggregateInterface::attachShared()}
+     */
+    public function attachAggregate(SharedListenerAggregateInterface $aggregate, $priority = 1)
+    {
+        return $aggregate->attachShared($this, $priority);
+    }
+
+    /**
+     * Detach a listener from an event offered by a given resource
+     *
+     * @param  string|int $id
+     * @param  CallbackHandler $listener
+     * @return bool Returns true if event and listener found, and unsubscribed; returns false if either event or listener not found
+     */
+    public function detach($id, CallbackHandler $listener)
+    {
+        if (!array_key_exists($id, $this->identifiers)) {
+            return false;
+        }
+        return $this->identifiers[$id]->detach($listener);
+    }
+
+    /**
+     * Detach a listener aggregate
+     *
+     * Listener aggregates accept a SharedEventManagerInterface instance, and call detachShared()
+     * of all previously attached listeners.
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @return mixed return value of {@link SharedListenerAggregateInterface::detachShared()}
+     */
+    public function detachAggregate(SharedListenerAggregateInterface $aggregate)
+    {
+        return $aggregate->detachShared($this);
+    }
+
+    /**
+     * Retrieve all registered events for a given resource
+     *
+     * @param  string|int $id
+     * @return array
+     */
+    public function getEvents($id)
+    {
+        if (!array_key_exists($id, $this->identifiers)) {
+            //Check if there are any id wildcards listeners
+            if ('*' != $id && array_key_exists('*', $this->identifiers)) {
+                return $this->identifiers['*']->getEvents();
+            }
+            return false;
+        }
+        return $this->identifiers[$id]->getEvents();
+    }
+
+    /**
+     * Retrieve all listeners for a given identifier and event
+     *
+     * @param  string|int $id
+     * @param  string|int $event
+     * @return false|PriorityQueue
+     */
+    public function getListeners($id, $event)
+    {
+        if (!array_key_exists($id, $this->identifiers)) {
+            return false;
+        }
+        return $this->identifiers[$id]->getListeners($event);
+    }
+
+    /**
+     * Clear all listeners for a given identifier, optionally for a specific event
+     *
+     * @param  string|int $id
+     * @param  null|string $event
+     * @return bool
+     */
+    public function clearListeners($id, $event = null)
+    {
+        if (!array_key_exists($id, $this->identifiers)) {
+            return false;
+        }
+
+        if (null === $event) {
+            unset($this->identifiers[$id]);
+            return true;
+        }
+
+        return $this->identifiers[$id]->clearListeners($event);
+    }
+}

vendor/zendframework/zend-eventmanager/src/SharedEventManagerAwareInterface.php

@@ -0,0 +1,38 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface to automate setter injection for a SharedEventManagerInterface instance
+ */
+interface SharedEventManagerAwareInterface
+{
+    /**
+     * Inject a SharedEventManager instance
+     *
+     * @param  SharedEventManagerInterface $sharedEventManager
+     * @return SharedEventManagerAwareInterface
+     */
+    public function setSharedManager(SharedEventManagerInterface $sharedEventManager);
+
+    /**
+     * Get shared collections container
+     *
+     * @return SharedEventManagerInterface
+     */
+    public function getSharedManager();
+
+    /**
+     * Remove any shared collections
+     *
+     * @return void
+     */
+    public function unsetSharedManager();
+}

vendor/zendframework/zend-eventmanager/src/SharedEventManagerInterface.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+use Zend\Stdlib\CallbackHandler;
+use Zend\Stdlib\PriorityQueue;
+
+/**
+ * Interface for shared event listener collections
+ */
+interface SharedEventManagerInterface
+{
+    /**
+     * Retrieve all listeners for a given identifier and event
+     *
+     * @param  string|int $id
+     * @param  string|int $event
+     * @return false|PriorityQueue
+     */
+    public function getListeners($id, $event);
+
+    /**
+     * Attach a listener to an event
+     *
+     * @param  string|array $id Identifier(s) for event emitting component(s)
+     * @param  string $event
+     * @param  callable $callback PHP Callback
+     * @param  int $priority Priority at which listener should execute
+     * @return CallbackHandler|array Either CallbackHandler or array of CallbackHandlers
+     */
+    public function attach($id, $event, $callback, $priority = 1);
+
+    /**
+     * Detach a listener from an event offered by a given resource
+     *
+     * @param  string|int $id
+     * @param  CallbackHandler $listener
+     * @return bool Returns true if event and listener found, and unsubscribed; returns false if either event or listener not found
+     */
+    public function detach($id, CallbackHandler $listener);
+
+    /**
+     * Retrieve all registered events for a given resource
+     *
+     * @param  string|int $id
+     * @return array
+     */
+    public function getEvents($id);
+
+    /**
+     * Clear all listeners for a given identifier, optionally for a specific event
+     *
+     * @param  string|int $id
+     * @param  null|string $event
+     * @return bool
+     */
+    public function clearListeners($id, $event = null);
+}

vendor/zendframework/zend-eventmanager/src/SharedListenerAggregateInterface.php

@@ -0,0 +1,38 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface for self-registering event listeners.
+ *
+ * Classes implementing this interface may be registered by name or instance
+ * with a SharedEventManager, without an event name. The {@link attach()} method will
+ * then be called with the current SharedEventManager instance, allowing the class to
+ * wire up one or more listeners.
+ */
+interface SharedListenerAggregateInterface
+{
+    /**
+     * Attach one or more listeners
+     *
+     * Implementors may add an optional $priority argument; the SharedEventManager
+     * implementation will pass this to the aggregate.
+     *
+     * @param SharedEventManagerInterface $events
+     */
+    public function attachShared(SharedEventManagerInterface $events);
+
+    /**
+     * Detach all previously attached listeners
+     *
+     * @param SharedEventManagerInterface $events
+     */
+    public function detachShared(SharedEventManagerInterface $events);
+}

vendor/zendframework/zend-eventmanager/src/StaticEventManager.php

@@ -0,0 +1,81 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Static version of EventManager
+ */
+class StaticEventManager extends SharedEventManager
+{
+    /**
+     * @var SharedEventManagerInterface
+     */
+    protected static $instance;
+
+    /**
+     * Singleton
+     */
+    protected function __construct()
+    {
+    }
+
+    /**
+     * Singleton
+     *
+     * @return void
+     */
+    private function __clone()
+    {
+    }
+
+    /**
+     * Retrieve instance
+     *
+     * @return StaticEventManager
+     */
+    public static function getInstance()
+    {
+        if (null === static::$instance) {
+            static::setInstance(new static());
+        }
+        return static::$instance;
+    }
+
+    /**
+     * Set the singleton to a specific SharedEventManagerInterface instance
+     *
+     * @param SharedEventManagerInterface $instance
+     * @return void
+     */
+    public static function setInstance(SharedEventManagerInterface $instance)
+    {
+        static::$instance = $instance;
+    }
+
+    /**
+     * Is a singleton instance defined?
+     *
+     * @return bool
+     */
+    public static function hasInstance()
+    {
+        return (static::$instance instanceof SharedEventManagerInterface);
+    }
+
+    /**
+     * Reset the singleton instance
+     *
+     * @return void
+     */
+    public static function resetInstance()
+    {
+        static::$instance = null;
+    }
+}