PDF rausgenommen

msd2/myoos/vendor/doctrine/reflection/.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/reflection/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/reflection/README.md

@@ -0,0 +1,13 @@
+# Doctrine Reflection
+
+[![Build Status](https://travis-ci.org/doctrine/reflection.svg)](https://travis-ci.org/doctrine/reflection)
+[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/doctrine/reflection/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/doctrine/reflection/?branch=master)
+[![Code Coverage](https://scrutinizer-ci.com/g/doctrine/reflection/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/doctrine/reflection/?branch=master)
+
+The Doctrine Reflection project is a simple library used by the various Doctrine projects which adds some additional functionality on top of the reflection functionality that comes with PHP. It allows you to get the reflection information about classes, methods and properties statically.
+
+## More resources:
+
+* [Website](https://www.doctrine-project.org/)
+* [Documentation](https://www.doctrine-project.org/projects/doctrine-reflection/en/latest/)
+* [Downloads](https://github.com/doctrine/reflection/releases)

msd2/myoos/vendor/doctrine/reflection/composer.json

@@ -0,0 +1,44 @@
+{
+    "name": "doctrine/reflection",
+    "type": "library",
+    "description": "Doctrine Reflection component",
+    "keywords": ["reflection"],
+    "homepage": "https://www.doctrine-project.org/projects/reflection.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",
+        "ext-tokenizer": "*",
+        "doctrine/annotations": "^1.0"
+    },
+    "require-dev": {
+        "phpstan/phpstan": "^0.9.2",
+        "phpstan/phpstan-phpunit": "^0.9.4",
+        "phpunit/phpunit": "^7.0",
+        "doctrine/coding-standard": "^4.0",
+        "doctrine/common": "^2.8",
+        "squizlabs/php_codesniffer": "^3.0"
+    },
+    "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/reflection/docs/en/index.rst

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

msd2/myoos/vendor/doctrine/reflection/docs/en/reference/index.rst

@@ -0,0 +1,85 @@
+Introduction
+============
+
+The Doctrine Reflection project is a simple library used by the various Doctrine projects which adds some additional
+functionality on top of the reflection functionality that comes with PHP. It allows you to get the reflection information
+about classes, methods and properties statically.
+
+Installation
+============
+
+The library can easily be installed with composer.
+
+.. code-block:: sh
+
+    $ composer require doctrine/reflection
+
+Setup
+=====
+
+.. code-block:: php
+
+    use Doctrine\Common\Reflection\Psr0FindFile;
+    use Doctrine\Common\Reflection\StaticReflectionParser;
+    use App\Model\User;
+
+    $finder = new Psr0FindFile(['App' => [
+        '/path/to/project/src/App'
+    ]]);
+
+    $staticReflectionParser = new StaticReflectionParser(User::class, $finder);
+
+Usage
+=====
+
+.. code-block:: php
+
+    echo $staticReflectionParser->getClassName();
+    echo $staticReflectionParser->getNamespaceName();
+
+StaticReflectionClass
+=====================
+
+.. code-block:: php
+
+    $staticReflectionClass = $staticReflectionParser->getReflectionClass();
+
+    echo $staticReflectionClass->getName();
+
+    echo $staticReflectionClass->getDocComment();
+
+    echo $staticReflectionClass->getNamespaceName();
+
+    print_r($staticReflectionClass->getUseStatements());
+
+StaticReflectionMethod
+======================
+
+.. code-block:: php
+
+    $staticReflectionMethod = $staticReflectionParser->getReflectionMethod('getSomething');
+
+    echo $staticReflectionMethod->getName();
+
+    echo $staticReflectionMethod->getDeclaringClass();
+
+    echo $staticReflectionMethod->getNamespaceName();
+
+    echo $staticReflectionMethod->getDocComment();
+
+    print_r($staticReflectionMethod->getUseStatements());
+
+StaticReflectionProperty
+========================
+
+.. code-block:: php
+
+    $staticReflectionProperty = $staticReflectionParser->getReflectionProperty('something');
+
+    echo $staticReflectionProperty->getName();
+
+    echo $staticReflectionProperty->getDeclaringClass();
+
+    echo $staticReflectionProperty->getDocComment();
+
+    print_r($staticReflectionProperty->getUseStatements());

msd2/myoos/vendor/doctrine/reflection/docs/en/sidebar.rst

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

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/ClassFinderInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+/**
+ * Finds a class in a PSR-0 structure.
+ */
+interface ClassFinderInterface
+{
+    /**
+     * Finds a class.
+     *
+     * @param string $class The name of the class.
+     *
+     * @return string|null The name of the class or NULL if not found.
+     */
+    public function findFile($class);
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/Psr0FindFile.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+use const DIRECTORY_SEPARATOR;
+use function is_file;
+use function str_replace;
+use function strpos;
+use function strrpos;
+use function substr;
+
+/**
+ * Finds a class in a PSR-0 structure.
+ */
+class Psr0FindFile implements ClassFinderInterface
+{
+    /**
+     * The PSR-0 prefixes.
+     *
+     * @var string[][]
+     */
+    protected $prefixes;
+
+    /**
+     * @param string[][] $prefixes An array of prefixes. Each key is a PHP namespace and each value is
+     *                        a list of directories.
+     */
+    public function __construct($prefixes)
+    {
+        $this->prefixes = $prefixes;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function findFile($class)
+    {
+        if ($class[0] === '\\') {
+            $class = substr($class, 1);
+        }
+
+        $lastNsPos = strrpos($class, '\\');
+
+        if ($lastNsPos !== false) {
+            // namespaced class name
+            $classPath = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, 0, $lastNsPos)) . DIRECTORY_SEPARATOR;
+            $className = substr($class, $lastNsPos + 1);
+        } else {
+            // PEAR-like class name
+            $classPath = null;
+            $className = $class;
+        }
+
+        $classPath .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
+
+        foreach ($this->prefixes as $prefix => $dirs) {
+            if (strpos($class, $prefix) !== 0) {
+                continue;
+            }
+
+            foreach ($dirs as $dir) {
+                if (is_file($dir . DIRECTORY_SEPARATOR . $classPath)) {
+                    return $dir . DIRECTORY_SEPARATOR . $classPath;
+                }
+            }
+        }
+
+        return null;
+    }
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/ReflectionProviderInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+interface ReflectionProviderInterface
+{
+    /**
+     * Gets the ReflectionClass equivalent for this class.
+     *
+     * @return \ReflectionClass
+     */
+    public function getReflectionClass();
+
+    /**
+     * Gets the ReflectionMethod equivalent for this class.
+     *
+     * @param string $name
+     *
+     * @return \ReflectionMethod
+     */
+    public function getReflectionMethod($name);
+
+    /**
+     * Gets the ReflectionProperty equivalent for this class.
+     *
+     * @param string $name
+     *
+     * @return \ReflectionProperty
+     */
+    public function getReflectionProperty($name);
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/RuntimePublicReflectionProperty.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+use Doctrine\Common\Proxy\Proxy;
+use ReflectionProperty;
+
+/**
+ * PHP Runtime Reflection Public Property - special overrides for public properties.
+ *
+ */
+class RuntimePublicReflectionProperty extends ReflectionProperty
+{
+    /**
+     * {@inheritDoc}
+     *
+     * Checks is the value actually exist before fetching it.
+     * This is to avoid calling `__get` on the provided $object if it
+     * is a {@see \Doctrine\Common\Proxy\Proxy}.
+     */
+    public function getValue($object = null)
+    {
+        $name = $this->getName();
+
+        if ($object instanceof Proxy && ! $object->__isInitialized()) {
+            $originalInitializer = $object->__getInitializer();
+            $object->__setInitializer(null);
+            $val = $object->$name ?? null;
+            $object->__setInitializer($originalInitializer);
+
+            return $val;
+        }
+
+        return isset($object->$name) ? parent::getValue($object) : null;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Avoids triggering lazy loading via `__set` if the provided object
+     * is a {@see \Doctrine\Common\Proxy\Proxy}.
+     * @link https://bugs.php.net/bug.php?id=63463
+     */
+    public function setValue($object, $value = null)
+    {
+        if (! ($object instanceof Proxy && ! $object->__isInitialized())) {
+            parent::setValue($object, $value);
+
+            return;
+        }
+
+        $originalInitializer = $object->__getInitializer();
+        $object->__setInitializer(null);
+        parent::setValue($object, $value);
+        $object->__setInitializer($originalInitializer);
+    }
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/StaticReflectionClass.php

@@ -0,0 +1,413 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+use ReflectionClass;
+use ReflectionException;
+
+class StaticReflectionClass extends ReflectionClass
+{
+    /**
+     * The static reflection parser object.
+     *
+     * @var StaticReflectionParser
+     */
+    private $staticReflectionParser;
+
+    public function __construct(StaticReflectionParser $staticReflectionParser)
+    {
+        $this->staticReflectionParser = $staticReflectionParser;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return $this->staticReflectionParser->getClassName();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDocComment()
+    {
+        return $this->staticReflectionParser->getDocComment();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getNamespaceName()
+    {
+        return $this->staticReflectionParser->getNamespaceName();
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getUseStatements()
+    {
+        return $this->staticReflectionParser->getUseStatements();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getMethod($name)
+    {
+        return $this->staticReflectionParser->getReflectionMethod($name);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getProperty($name)
+    {
+        return $this->staticReflectionParser->getReflectionProperty($name);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public static function export($argument, $return = false)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConstant($name)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConstants()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConstructor()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDefaultProperties()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getEndLine()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getExtension()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getExtensionName()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getFileName()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getInterfaceNames()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getInterfaces()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getMethods($filter = null)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getModifiers()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getParentClass()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getProperties($filter = null)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getShortName()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getStartLine()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getStaticProperties()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getStaticPropertyValue($name, $default = '')
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTraitAliases()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTraitNames()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTraits()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasConstant($name)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasMethod($name)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasProperty($name)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function implementsInterface($interface)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function inNamespace()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isAbstract()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isCloneable()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isFinal()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInstance($object)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInstantiable()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInterface()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInternal()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isIterateable()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isSubclassOf($class)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isTrait()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isUserDefined()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function newInstance($args)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function newInstanceArgs(array $args = [])
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function newInstanceWithoutConstructor()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setStaticPropertyValue($name, $value)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __toString()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/StaticReflectionMethod.php

@@ -0,0 +1,344 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+use ReflectionException;
+use ReflectionMethod;
+
+class StaticReflectionMethod extends ReflectionMethod
+{
+    /**
+     * The PSR-0 parser object.
+     *
+     * @var StaticReflectionParser
+     */
+    protected $staticReflectionParser;
+
+    /**
+     * The name of the method.
+     *
+     * @var string
+     */
+    protected $methodName;
+
+    /**
+     * @param string $methodName
+     */
+    public function __construct(StaticReflectionParser $staticReflectionParser, $methodName)
+    {
+        $this->staticReflectionParser = $staticReflectionParser;
+        $this->methodName             = $methodName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return $this->methodName;
+    }
+
+    /**
+     * @return StaticReflectionParser
+     */
+    protected function getStaticReflectionParser()
+    {
+        return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('method', $this->methodName);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDeclaringClass()
+    {
+        return $this->getStaticReflectionParser()->getReflectionClass();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getNamespaceName()
+    {
+        return $this->getStaticReflectionParser()->getNamespaceName();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDocComment()
+    {
+        return $this->getStaticReflectionParser()->getDocComment('method', $this->methodName);
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getUseStatements()
+    {
+        return $this->getStaticReflectionParser()->getUseStatements();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public static function export($class, $name, $return = false)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getClosure($object)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getModifiers()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getPrototype()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function invoke($object, $parameter = null)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function invokeArgs($object, array $args)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isAbstract()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isConstructor()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isDestructor()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isFinal()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isPrivate()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isProtected()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isPublic()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isStatic()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setAccessible($accessible)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __toString()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getClosureThis()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getEndLine()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getExtension()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getExtensionName()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getFileName()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getNumberOfParameters()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getNumberOfRequiredParameters()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getParameters()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getShortName()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getStartLine()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getStaticVariables()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function inNamespace()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isClosure()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isDeprecated()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInternal()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isUserDefined()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function returnsReference()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/StaticReflectionParser.php

@@ -0,0 +1,328 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+use Doctrine\Common\Annotations\TokenParser;
+use ReflectionException;
+use const T_CLASS;
+use const T_DOC_COMMENT;
+use const T_EXTENDS;
+use const T_FUNCTION;
+use const T_PAAMAYIM_NEKUDOTAYIM;
+use const T_PRIVATE;
+use const T_PROTECTED;
+use const T_PUBLIC;
+use const T_STRING;
+use const T_USE;
+use const T_VAR;
+use const T_VARIABLE;
+use function array_merge;
+use function file_get_contents;
+use function ltrim;
+use function preg_match;
+use function sprintf;
+use function strpos;
+use function strrpos;
+use function strtolower;
+use function substr;
+
+/**
+ * Parses a file for namespaces/use/class declarations.
+ */
+class StaticReflectionParser implements ReflectionProviderInterface
+{
+    /**
+     * The fully qualified class name.
+     *
+     * @var string
+     */
+    protected $className;
+
+    /**
+     * The short class name.
+     *
+     * @var string
+     */
+    protected $shortClassName;
+
+    /**
+     * Whether the caller only wants class annotations.
+     *
+     * @var bool
+     */
+    protected $classAnnotationOptimize;
+
+    /**
+     * A ClassFinder object which finds the class.
+     *
+     * @var ClassFinderInterface
+     */
+    protected $finder;
+
+    /**
+     * Whether the parser has run.
+     *
+     * @var bool
+     */
+    protected $parsed = false;
+
+    /**
+     * The namespace of the class.
+     *
+     * @var string
+     */
+    protected $namespace = '';
+
+    /**
+     * The use statements of the class.
+     *
+     * @var string[]
+     */
+    protected $useStatements = [];
+
+    /**
+     * The docComment of the class.
+     *
+     * @var mixed[]
+     */
+    protected $docComment = [
+        'class' => '',
+        'property' => [],
+        'method' => [],
+    ];
+
+    /**
+     * The name of the class this class extends, if any.
+     *
+     * @var string
+     */
+    protected $parentClassName = '';
+
+    /**
+     * The parent PSR-0 Parser.
+     *
+     * @var \Doctrine\Common\Reflection\StaticReflectionParser
+     */
+    protected $parentStaticReflectionParser;
+
+    /**
+     * Parses a class residing in a PSR-0 hierarchy.
+     *
+     * @param string               $className               The full, namespaced class name.
+     * @param ClassFinderInterface $finder                  A ClassFinder object which finds the class.
+     * @param bool                 $classAnnotationOptimize Only retrieve the class docComment.
+     *                                                         Presumes there is only one statement per line.
+     */
+    public function __construct($className, $finder, $classAnnotationOptimize = false)
+    {
+        $this->className = ltrim($className, '\\');
+        $lastNsPos       = strrpos($this->className, '\\');
+
+        if ($lastNsPos !== false) {
+            $this->namespace      = substr($this->className, 0, $lastNsPos);
+            $this->shortClassName = substr($this->className, $lastNsPos + 1);
+        } else {
+            $this->shortClassName = $this->className;
+        }
+
+        $this->finder                  = $finder;
+        $this->classAnnotationOptimize = $classAnnotationOptimize;
+    }
+
+    /**
+     * @return void
+     */
+    protected function parse()
+    {
+        $fileName = $this->finder->findFile($this->className);
+
+        if ($this->parsed || ! $fileName) {
+            return;
+        }
+        $this->parsed = true;
+        $contents     = file_get_contents($fileName);
+        if ($this->classAnnotationOptimize) {
+            $regex = sprintf('/\A.*^\s*((abstract|final)\s+)?class\s+%s\s+/sm', $this->shortClassName);
+
+            if (preg_match($regex, $contents, $matches)) {
+                $contents = $matches[0];
+            }
+        }
+        $tokenParser = new TokenParser($contents);
+        $docComment  = '';
+        $last_token  = false;
+
+        while ($token = $tokenParser->next(false)) {
+            switch ($token[0]) {
+                case T_USE:
+                    $this->useStatements = array_merge($this->useStatements, $tokenParser->parseUseStatement());
+                    break;
+                case T_DOC_COMMENT:
+                    $docComment = $token[1];
+                    break;
+                case T_CLASS:
+                    if ($last_token !== T_PAAMAYIM_NEKUDOTAYIM) {
+                        $this->docComment['class'] = $docComment;
+                        $docComment                = '';
+                    }
+                    break;
+                case T_VAR:
+                case T_PRIVATE:
+                case T_PROTECTED:
+                case T_PUBLIC:
+                    $token = $tokenParser->next();
+                    if ($token[0] === T_VARIABLE) {
+                        $propertyName                                = substr($token[1], 1);
+                        $this->docComment['property'][$propertyName] = $docComment;
+                        continue 2;
+                    }
+                    if ($token[0] !== T_FUNCTION) {
+                        // For example, it can be T_FINAL.
+                        continue 2;
+                    }
+                    // No break.
+                case T_FUNCTION:
+                    // The next string after function is the name, but
+                    // there can be & before the function name so find the
+                    // string.
+                    while (($token = $tokenParser->next()) && $token[0] !== T_STRING) {
+                        continue;
+                    }
+                    $methodName                              = $token[1];
+                    $this->docComment['method'][$methodName] = $docComment;
+                    $docComment                              = '';
+                    break;
+                case T_EXTENDS:
+                    $this->parentClassName = $tokenParser->parseClass();
+                    $nsPos                 = strpos($this->parentClassName, '\\');
+                    $fullySpecified        = false;
+                    if ($nsPos === 0) {
+                        $fullySpecified = true;
+                    } else {
+                        if ($nsPos) {
+                            $prefix  = strtolower(substr($this->parentClassName, 0, $nsPos));
+                            $postfix = substr($this->parentClassName, $nsPos);
+                        } else {
+                            $prefix  = strtolower($this->parentClassName);
+                            $postfix = '';
+                        }
+                        foreach ($this->useStatements as $alias => $use) {
+                            if ($alias !== $prefix) {
+                                continue;
+                            }
+
+                            $this->parentClassName = '\\' . $use . $postfix;
+                            $fullySpecified        = true;
+                        }
+                    }
+                    if (! $fullySpecified) {
+                        $this->parentClassName = '\\' . $this->namespace . '\\' . $this->parentClassName;
+                    }
+                    break;
+            }
+
+            $last_token = $token[0];
+        }
+    }
+
+    /**
+     * @return StaticReflectionParser
+     */
+    protected function getParentStaticReflectionParser()
+    {
+        if (empty($this->parentStaticReflectionParser)) {
+            $this->parentStaticReflectionParser = new static($this->parentClassName, $this->finder);
+        }
+
+        return $this->parentStaticReflectionParser;
+    }
+
+    /**
+     * @return string
+     */
+    public function getClassName()
+    {
+        return $this->className;
+    }
+
+    /**
+     * @return string
+     */
+    public function getNamespaceName()
+    {
+        return $this->namespace;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getReflectionClass()
+    {
+        return new StaticReflectionClass($this);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getReflectionMethod($methodName)
+    {
+        return new StaticReflectionMethod($this, $methodName);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getReflectionProperty($propertyName)
+    {
+        return new StaticReflectionProperty($this, $propertyName);
+    }
+
+    /**
+     * Gets the use statements from this file.
+     *
+     * @return string[]
+     */
+    public function getUseStatements()
+    {
+        $this->parse();
+
+        return $this->useStatements;
+    }
+
+    /**
+     * Gets the doc comment.
+     *
+     * @param string $type The type: 'class', 'property' or 'method'.
+     * @param string $name The name of the property or method, not needed for 'class'.
+     *
+     * @return string The doc comment, empty string if none.
+     */
+    public function getDocComment($type = 'class', $name = '')
+    {
+        $this->parse();
+
+        return $name ? $this->docComment[$type][$name] : $this->docComment[$type];
+    }
+
+    /**
+     * Gets the PSR-0 parser for the declaring class.
+     *
+     * @param string $type The type: 'property' or 'method'.
+     * @param string $name The name of the property or method.
+     *
+     * @return StaticReflectionParser A static reflection parser for the declaring class.
+     *
+     * @throws ReflectionException
+     */
+    public function getStaticReflectionParserForDeclaringClass($type, $name)
+    {
+        $this->parse();
+        if (isset($this->docComment[$type][$name])) {
+            return $this;
+        }
+        if (! empty($this->parentClassName)) {
+            return $this->getParentStaticReflectionParser()->getStaticReflectionParserForDeclaringClass($type, $name);
+        }
+        throw new ReflectionException('Invalid ' . $type . ' "' . $name . '"');
+    }
+}

msd2/myoos/vendor/doctrine/reflection/lib/Doctrine/Common/Reflection/StaticReflectionProperty.php

@@ -0,0 +1,160 @@
+<?php
+
+namespace Doctrine\Common\Reflection;
+
+use ReflectionException;
+use ReflectionProperty;
+
+class StaticReflectionProperty extends ReflectionProperty
+{
+    /**
+     * The PSR-0 parser object.
+     *
+     * @var StaticReflectionParser
+     */
+    protected $staticReflectionParser;
+
+    /**
+     * The name of the property.
+     *
+     * @var string|null
+     */
+    protected $propertyName;
+
+    /**
+     * @param string|null $propertyName
+     */
+    public function __construct(StaticReflectionParser $staticReflectionParser, $propertyName)
+    {
+        $this->staticReflectionParser = $staticReflectionParser;
+        $this->propertyName           = $propertyName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return $this->propertyName;
+    }
+
+    /**
+     * @return StaticReflectionParser
+     */
+    protected function getStaticReflectionParser()
+    {
+        return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('property', $this->propertyName);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDeclaringClass()
+    {
+        return $this->getStaticReflectionParser()->getReflectionClass();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDocComment()
+    {
+        return $this->getStaticReflectionParser()->getDocComment('property', $this->propertyName);
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getUseStatements()
+    {
+        return $this->getStaticReflectionParser()->getUseStatements();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public static function export($class, $name, $return = false)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getModifiers()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getValue($object = null)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isDefault()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isPrivate()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isProtected()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isPublic()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isStatic()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setAccessible($accessible)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setValue($object, $value = null)
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __toString()
+    {
+        throw new ReflectionException('Method not implemented');
+    }
+}

msd2/myoos/vendor/doctrine/reflection/phpstan.neon

@@ -0,0 +1,6 @@
+includes:
+    - vendor/phpstan/phpstan-phpunit/extension.neon
+
+parameters:
+    ignoreErrors:
+        - '#Doctrine\\Common\\Reflection\\StaticReflection[a-zA-Z0-9_]+::__construct\(\) does not call parent constructor from Reflection[a-zA-Z0-9_]+#'