PDF rausgenommen

msd2/myoos/vendor/doctrine/event-manager/.scrutinizer.yml

@@ -0,0 +1,29 @@
+build:
+    nodes:
+        analysis:
+            environment:
+                php:
+                    version: 7.1
+            cache:
+                disabled: false
+                directories:
+                    - ~/.composer/cache
+            project_setup:
+                override: true
+            tests:
+                override:
+                    - php-scrutinizer-run
+                    - phpcs-run
+    dependencies:
+        override:
+            - composer install -noa
+
+tools:
+    external_code_coverage:
+        timeout: 600
+
+build_failure_conditions:
+    - 'elements.rating(<= C).new.exists'                        # No new classes/methods with a rating of C or worse allowed
+    - 'issues.label("coding-style").new.exists'                 # No new coding style issues allowed
+    - 'issues.severity(>= MAJOR).new.exists'                    # New issues of major or higher severity
+    - 'project.metric_change("scrutinizer.test_coverage", < 0)' # Code Coverage decreased from previous inspection

msd2/myoos/vendor/doctrine/event-manager/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2006-2015 Doctrine Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

msd2/myoos/vendor/doctrine/event-manager/README.md

@@ -0,0 +1,13 @@
+# Doctrine Event Manager
+
+[![Build Status](https://travis-ci.org/doctrine/event-manager.svg)](https://travis-ci.org/doctrine/event-manager)
+[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/doctrine/event-manager/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/doctrine/event-manager/?branch=master)
+[![Code Coverage](https://scrutinizer-ci.com/g/doctrine/event-manager/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/doctrine/event-manager/?branch=master)
+
+The Doctrine Event Manager is a library that provides a simple event system.
+
+## More resources:
+
+* [Website](https://www.doctrine-project.org/)
+* [Documentation](https://www.doctrine-project.org/projects/doctrine-event-manager/en/latest/)
+* [Downloads](https://github.com/doctrine/event-manager/releases)

msd2/myoos/vendor/doctrine/event-manager/composer.json

@@ -0,0 +1,41 @@
+{
+    "name": "doctrine/event-manager",
+    "type": "library",
+    "description": "Doctrine Event Manager component",
+    "keywords": ["eventmanager", "eventdispatcher", "event"],
+    "homepage": "https://www.doctrine-project.org/projects/event-manager.html",
+    "license": "MIT",
+    "authors": [
+        {"name": "Guilherme Blanco", "email": "guilhermeblanco@gmail.com"},
+        {"name": "Roman Borschel", "email": "roman@code-factory.org"},
+        {"name": "Benjamin Eberlei", "email": "kontakt@beberlei.de"},
+        {"name": "Jonathan Wage", "email": "jonwage@gmail.com"},
+        {"name": "Johannes Schmitt", "email": "schmittjoh@gmail.com"},
+        {"name": "Marco Pivetta", "email": "ocramius@gmail.com"}
+    ],
+    "require": {
+        "php": "^7.1"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^7.0",
+        "doctrine/coding-standard": "^4.0"
+    },
+    "conflict": {
+        "doctrine/common": "<2.9@dev"
+    },
+    "autoload": {
+        "psr-4": {
+            "Doctrine\\Common\\": "lib/Doctrine/Common"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Doctrine\\Tests\\": "tests/Doctrine/Tests"
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.0.x-dev"
+        }
+    }
+}

msd2/myoos/vendor/doctrine/event-manager/docs/en/index.rst

@@ -0,0 +1,22 @@
+Event Manager Documentation
+===========================
+
+The Doctrine Event Manager documentation is a reference guide to everything you need
+to know about the project.
+
+Getting Help
+------------
+
+If this documentation is not helping to answer questions you have about the
+Doctrine DBAL, don't panic. You can get help from different sources:
+
+-  Gitter chat room `#doctrine/event-manager <https://gitter.im/doctrine/event-manager>`_
+-  On `Stack Overflow <http://stackoverflow.com/questions/tagged/doctrine-event-manager>`_
+-  The `Doctrine Mailing List <http://groups.google.com/group/doctrine-user>`_
+-  Report a bug on `GitHub <https://github.com/doctrine/event-manager/issues>`_.
+
+Getting Started
+---------------
+
+The best way to get started is with the :doc:`Introduction <reference/index#introduction>` section
+in the documentation. Use the sidebar to browse other documentation for the Doctrine Event Manager.

msd2/myoos/vendor/doctrine/event-manager/docs/en/reference/index.rst

@@ -0,0 +1,133 @@
+Introduction
+============
+
+The Doctrine Event Manager is a simple event system used by the various Doctrine projects. It was originally built
+for the DBAL and ORM but over time other projects adopted it and now it is available as a standalone library.
+
+Installation
+============
+
+The library can easily be installed with composer.
+
+.. code-block:: sh
+
+    $ composer require doctrine/event-manager
+
+Setup
+=====
+
+The event system is controlled by the ``Doctrine\Common\EventManager`` class.
+
+.. code-block:: php
+
+    use Doctrine\Common\EventManager;
+
+    $eventManager = new EventManager();
+
+Listeners
+=========
+
+Now you are ready to listen for events. Here is an example of a custom event listener named ``TestEvent``.
+
+.. code-block:: php
+
+    use Doctrine\Common\EventArgs;
+    use Doctrine\Common\EventManager;
+
+    final class TestEvent
+    {
+        public const preFoo = 'preFoo';
+        public const postFoo = 'postFoo';
+
+        /** @var EventManager */
+        private $eventManager;
+
+        /** @var bool */
+        public $preFooInvoked = false;
+
+        /** @var bool */
+        public $postFooInvoked = false;
+
+        public function __construct(EventManager $eventManager)
+        {
+            $eventManager->addEventListener([self::preFoo, self::postFoo], $this);
+        }
+
+        public function preFoo(EventArgs $eventArgs) : void
+        {
+            $this->preFooInvoked = true;
+        }
+
+        public function postFoo(EventArgs $eventArgs) : void
+        {
+            $this->postFooInvoked = true;
+        }
+    }
+
+    // Create a new instance
+    $testEvent = new TestEvent($eventManager);
+
+Dispatching Events
+==================
+
+Now you can dispatch events with the ``dispatchEvent()`` method.
+
+.. code-block:: php
+
+    $eventManager->dispatchEvent(TestEvent::preFoo);
+    $eventManager->dispatchEvent(TestEvent::postFoo);
+
+Removing Event Listeners
+========================
+
+You can easily remove a listener with the ``removeEventListener()`` method.
+
+.. code-block:: php
+
+    $eventManager->removeEventListener([TestEvent::preFoo, TestEvent::postFoo], $testEvent);
+
+Event Subscribers
+=================
+
+The Doctrine event system also has a simple concept of event subscribers. We can define a simple ``TestEventSubscriber`` class which implements the ``Doctrine\Common\EventSubscriber`` interface with a ``getSubscribedEvents()`` method which returns an array of events it should be subscribed to.
+
+.. code-block:: php
+
+    use Doctrine\Common\EventSubscriber;
+
+    final class TestEventSubscriber implements EventSubscriber
+    {
+        /** @var bool */
+        public $preFooInvoked = false;
+
+        public function preFoo() : void
+        {
+            $this->preFooInvoked = true;
+        }
+
+        public function getSubscribedEvents() : array
+        {
+            return [TestEvent::preFoo];
+        }
+    }
+
+    $eventSubscriber = new TestEventSubscriber();
+    $eventManager->addEventSubscriber($eventSubscriber);
+
+.. note::
+
+    The array returned by the ``getSubscribedEvents()`` method is a simple array with the values being the event names. The subscriber must have a method that is named exactly like the event.
+
+Now when you dispatch an event, any event subscribers will be notified of that event.
+
+.. code-block:: php
+
+    $eventManager->dispatchEvent(TestEvent::preFoo);
+
+Now you can check the ``preFooInvoked`` property to see if the event subscriber was notified of the event:
+
+.. code-block:: php
+
+    if ($eventSubscriber->preFooInvoked) {
+        // the preFoo method was invoked
+    }

msd2/myoos/vendor/doctrine/event-manager/docs/en/sidebar.rst

@@ -0,0 +1,4 @@
+.. toctree::
+    :depth: 3
+
+    reference/index

msd2/myoos/vendor/doctrine/event-manager/lib/Doctrine/Common/EventArgs.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Common;
+
+/**
+ * EventArgs is the base class for classes containing event data.
+ *
+ * This class contains no event data. It is used by events that do not pass state
+ * information to an event handler when an event is raised. The single empty EventArgs
+ * instance can be obtained through {@link getEmptyInstance}.
+ */
+class EventArgs
+{
+    /**
+     * Single instance of EventArgs.
+     *
+     * @var EventArgs
+     */
+    private static $_emptyEventArgsInstance;
+
+    /**
+     * Gets the single, empty and immutable EventArgs instance.
+     *
+     * This instance will be used when events are dispatched without any parameter,
+     * like this: EventManager::dispatchEvent('eventname');
+     *
+     * The benefit from this is that only one empty instance is instantiated and shared
+     * (otherwise there would be instances for every dispatched in the abovementioned form).
+     *
+     * @see EventManager::dispatchEvent
+     *
+     * @link https://msdn.microsoft.com/en-us/library/system.eventargs.aspx
+     *
+     * @return EventArgs
+     */
+    public static function getEmptyInstance()
+    {
+        if (! self::$_emptyEventArgsInstance) {
+            self::$_emptyEventArgsInstance = new EventArgs();
+        }
+
+        return self::$_emptyEventArgsInstance;
+    }
+}

msd2/myoos/vendor/doctrine/event-manager/lib/Doctrine/Common/EventManager.php

@@ -0,0 +1,131 @@
+<?php
+namespace Doctrine\Common;
+
+use function spl_object_hash;
+
+/**
+ * The EventManager is the central point of Doctrine's event listener system.
+ * Listeners are registered on the manager and events are dispatched through the
+ * manager.
+ */
+class EventManager
+{
+    /**
+     * Map of registered listeners.
+     * <event> => <listeners>
+     *
+     * @var object[][]
+     */
+    private $_listeners = [];
+
+    /**
+     * Dispatches an event to all registered listeners.
+     *
+     * @param string         $eventName The name of the event to dispatch. The name of the event is
+     *                                  the name of the method that is invoked on listeners.
+     * @param EventArgs|null $eventArgs The event arguments to pass to the event handlers/listeners.
+     *                                  If not supplied, the single empty EventArgs instance is used.
+     *
+     * @return void
+     */
+    public function dispatchEvent($eventName, ?EventArgs $eventArgs = null)
+    {
+        if (! isset($this->_listeners[$eventName])) {
+            return;
+        }
+
+        $eventArgs = $eventArgs ?? EventArgs::getEmptyInstance();
+
+        foreach ($this->_listeners[$eventName] as $listener) {
+            $listener->$eventName($eventArgs);
+        }
+    }
+
+    /**
+     * Gets the listeners of a specific event or all listeners.
+     *
+     * @param string|null $event The name of the event.
+     *
+     * @return object[]|object[][] The event listeners for the specified event, or all event listeners.
+     */
+    public function getListeners($event = null)
+    {
+        return $event ? $this->_listeners[$event] : $this->_listeners;
+    }
+
+    /**
+     * Checks whether an event has any registered listeners.
+     *
+     * @param string $event
+     *
+     * @return bool TRUE if the specified event has any listeners, FALSE otherwise.
+     */
+    public function hasListeners($event)
+    {
+        return ! empty($this->_listeners[$event]);
+    }
+
+    /**
+     * Adds an event listener that listens on the specified events.
+     *
+     * @param string|string[] $events   The event(s) to listen on.
+     * @param object          $listener The listener object.
+     *
+     * @return void
+     */
+    public function addEventListener($events, $listener)
+    {
+        // Picks the hash code related to that listener
+        $hash = spl_object_hash($listener);
+
+        foreach ((array) $events as $event) {
+            // Overrides listener if a previous one was associated already
+            // Prevents duplicate listeners on same event (same instance only)
+            $this->_listeners[$event][$hash] = $listener;
+        }
+    }
+
+    /**
+     * Removes an event listener from the specified events.
+     *
+     * @param string|string[] $events
+     * @param object          $listener
+     *
+     * @return void
+     */
+    public function removeEventListener($events, $listener)
+    {
+        // Picks the hash code related to that listener
+        $hash = spl_object_hash($listener);
+
+        foreach ((array) $events as $event) {
+            unset($this->_listeners[$event][$hash]);
+        }
+    }
+
+    /**
+     * Adds an EventSubscriber. The subscriber is asked for all the events it is
+     * interested in and added as a listener for these events.
+     *
+     * @param EventSubscriber $subscriber The subscriber.
+     *
+     * @return void
+     */
+    public function addEventSubscriber(EventSubscriber $subscriber)
+    {
+        $this->addEventListener($subscriber->getSubscribedEvents(), $subscriber);
+    }
+
+    /**
+     * Removes an EventSubscriber. The subscriber is asked for all the events it is
+     * interested in and removed as a listener for these events.
+     *
+     * @param EventSubscriber $subscriber The subscriber.
+     *
+     * @return void
+     */
+    public function removeEventSubscriber(EventSubscriber $subscriber)
+    {
+        $this->removeEventListener($subscriber->getSubscribedEvents(), $subscriber);
+    }
+}

msd2/myoos/vendor/doctrine/event-manager/lib/Doctrine/Common/EventSubscriber.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Common;
+
+/**
+ * An EventSubscriber knows himself what events he is interested in.
+ * If an EventSubscriber is added to an EventManager, the manager invokes
+ * {@link getSubscribedEvents} and registers the subscriber as a listener for all
+ * returned events.
+ */
+interface EventSubscriber
+{
+    /**
+     * Returns an array of events this subscriber wants to listen to.
+     *
+     * @return string[]
+     */
+    public function getSubscribedEvents();
+}