Actualización

vendor/doctrine/orm/lib/Doctrine/ORM/Cache.php

@@ -0,0 +1,178 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+/**
+ * Provides an API for querying/managing the second level cache regions.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface Cache
+{
+    const DEFAULT_QUERY_REGION_NAME = 'query_cache_region';
+
+    const DEFAULT_TIMESTAMP_REGION_NAME = 'timestamp_cache_region';
+
+    /**
+     * May read items from the cache, but will not add items.
+     */
+    const MODE_GET = 1;
+
+    /**
+     * Will never read items from the cache,
+     * but will add items to the cache as it reads them from the database.
+     */
+    const MODE_PUT = 2;
+
+    /**
+     * May read items from the cache, and add items to the cache.
+     */
+    const MODE_NORMAL = 3;
+
+    /**
+     * The query will never read items from the cache,
+     * but will refresh items to the cache as it reads them from the database.
+     */
+    const MODE_REFRESH = 4;
+
+    /**
+     * @param string $className The entity class.
+     *
+     * @return \Doctrine\ORM\Cache\Region|null
+     */
+    public function getEntityCacheRegion($className);
+
+    /**
+     * @param string $className   The entity class.
+     * @param string $association The field name that represents the association.
+     *
+     * @return \Doctrine\ORM\Cache\Region|null
+     */
+    public function getCollectionCacheRegion($className, $association);
+
+    /**
+     * Determine whether the cache contains data for the given entity "instance".
+     *
+     * @param string $className  The entity class.
+     * @param mixed  $identifier The entity identifier
+     *
+     * @return boolean true if the underlying cache contains corresponding data; false otherwise.
+     */
+    public function containsEntity($className, $identifier);
+
+    /**
+     * Evicts the entity data for a particular entity "instance".
+     *
+     * @param string $className  The entity class.
+     * @param mixed  $identifier The entity identifier.
+     *
+     * @return void
+     */
+    public function evictEntity($className, $identifier);
+
+    /**
+     * Evicts all entity data from the given region.
+     *
+     * @param string $className The entity metadata.
+     *
+     * @return void
+     */
+    public function evictEntityRegion($className);
+
+    /**
+     * Evict data from all entity regions.
+     *
+     * @return void
+     */
+    public function evictEntityRegions();
+
+    /**
+     * Determine whether the cache contains data for the given collection.
+     *
+     * @param string $className       The entity class.
+     * @param string $association     The field name that represents the association.
+     * @param mixed  $ownerIdentifier The identifier of the owning entity.
+     *
+     * @return boolean true if the underlying cache contains corresponding data; false otherwise.
+     */
+    public function containsCollection($className, $association, $ownerIdentifier);
+
+    /**
+     * Evicts the cache data for the given identified collection instance.
+     *
+     * @param string $className       The entity class.
+     * @param string $association     The field name that represents the association.
+     * @param mixed  $ownerIdentifier The identifier of the owning entity.
+     *
+     * @return void
+     */
+    public function evictCollection($className, $association, $ownerIdentifier);
+
+    /**
+     * Evicts all entity data from the given region.
+     *
+     * @param string $className   The entity class.
+     * @param string $association The field name that represents the association.
+     *
+     * @return void
+     */
+    public function evictCollectionRegion($className, $association);
+
+    /**
+     * Evict data from all collection regions.
+     *
+     * @return void
+     */
+    public function evictCollectionRegions();
+
+    /**
+     * Determine whether the cache contains data for the given query.
+     *
+     * @param string $regionName The cache name given to the query.
+     *
+     * @return boolean true if the underlying cache contains corresponding data; false otherwise.
+     */
+    public function containsQuery($regionName);
+
+    /**
+     * Evicts all cached query results under the given name, or default query cache if the region name is NULL.
+     *
+     * @param string|null $regionName The cache name associated to the queries being cached.
+     */
+    public function evictQueryRegion($regionName = null);
+
+    /**
+     * Evict data from all query regions.
+     *
+     * @return void
+     */
+    public function evictQueryRegions();
+
+    /**
+     * Get query cache by region name or create a new one if none exist.
+     *
+     * @param string|null $regionName Query cache region name, or default query cache if the region name is NULL.
+     *
+     * @return \Doctrine\ORM\Cache\QueryCache The Query Cache associated with the region name.
+     */
+    public function getQueryCache($regionName = null);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/AssociationCacheEntry.php

@@ -0,0 +1,68 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Association cache entry
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class AssociationCacheEntry implements CacheEntry
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var array The entity identifier
+     */
+    public $identifier;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var string The entity class name
+     */
+    public $class;
+
+    /**
+     * @param string $class      The entity class.
+     * @param array  $identifier The entity identifier.
+     */
+    public function __construct($class, array $identifier)
+    {
+        $this->class       = $class;
+        $this->identifier  = $identifier;
+    }
+
+    /**
+     * Creates a new AssociationCacheEntry
+     *
+     * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
+     *
+     * @param array $values array containing property values
+     *
+     * @return AssociationCacheEntry
+     */
+    public static function __set_state(array $values)
+    {
+        return new self($values['class'], $values['identifier']);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CacheConfiguration.php

@@ -0,0 +1,128 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Cache\Logging\CacheLogger;
+
+/**
+ * Configuration container for second-level cache.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class CacheConfiguration
+{
+    /**
+     * @var \Doctrine\ORM\Cache\CacheFactory|null
+     */
+    private $cacheFactory;
+
+    /**
+     * @var \Doctrine\ORM\Cache\RegionsConfiguration|null
+     */
+    private $regionsConfig;
+
+    /**
+     * @var \Doctrine\ORM\Cache\Logging\CacheLogger|null
+     */
+    private $cacheLogger;
+
+    /**
+     * @var \Doctrine\ORM\Cache\QueryCacheValidator|null
+     */
+    private $queryValidator;
+
+    /**
+     * @return \Doctrine\ORM\Cache\CacheFactory|null
+     */
+    public function getCacheFactory()
+    {
+        return $this->cacheFactory;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\CacheFactory $factory
+     *
+     * @return void
+     */
+    public function setCacheFactory(CacheFactory $factory)
+    {
+        $this->cacheFactory = $factory;
+    }
+
+    /**
+     * @return \Doctrine\ORM\Cache\Logging\CacheLogger|null
+     */
+    public function getCacheLogger()
+    {
+         return $this->cacheLogger;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\Logging\CacheLogger $logger
+     */
+    public function setCacheLogger(CacheLogger $logger)
+    {
+        $this->cacheLogger = $logger;
+    }
+
+    /**
+     * @return \Doctrine\ORM\Cache\RegionsConfiguration
+     */
+    public function getRegionsConfiguration()
+    {
+        if ($this->regionsConfig === null) {
+            $this->regionsConfig = new RegionsConfiguration();
+        }
+
+        return $this->regionsConfig;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\RegionsConfiguration $regionsConfig
+     */
+    public function setRegionsConfiguration(RegionsConfiguration $regionsConfig)
+    {
+        $this->regionsConfig = $regionsConfig;
+    }
+
+    /**
+     * @return \Doctrine\ORM\Cache\QueryCacheValidator
+     */
+    public function getQueryValidator()
+    {
+        if ($this->queryValidator === null) {
+            $this->queryValidator = new TimestampQueryCacheValidator(
+                $this->cacheFactory->getTimestampRegion()
+            );
+        }
+
+         return $this->queryValidator;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\QueryCacheValidator $validator
+     */
+    public function setQueryValidator(QueryCacheValidator $validator)
+    {
+        $this->queryValidator = $validator;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CacheEntry.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Cache entry interface
+ *
+ * <b>IMPORTANT NOTE:</b>
+ *
+ * Fields of classes that implement CacheEntry are public for performance reason.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface CacheEntry
+{
+
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CacheException.php

@@ -0,0 +1,73 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\ORMException;
+
+/**
+ * Exception for cache.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class CacheException extends ORMException
+{
+    /**
+     * @param string $sourceEntity
+     * @param string $fieldName
+     *
+     * @return \Doctrine\ORM\Cache\CacheException
+     */
+    public static function updateReadOnlyCollection($sourceEntity, $fieldName)
+    {
+        return new self(sprintf('Cannot update a readonly collection "%s#%s"', $sourceEntity, $fieldName));
+    }
+
+    /**
+     * @param string $entityName
+     *
+     * @return \Doctrine\ORM\Cache\CacheException
+     */
+    public static function updateReadOnlyEntity($entityName)
+    {
+        return new self(sprintf('Cannot update a readonly entity "%s"', $entityName));
+    }
+
+    /**
+     * @param string $entityName
+     *
+     * @return \Doctrine\ORM\Cache\CacheException
+     */
+    public static function nonCacheableEntity($entityName)
+    {
+        return new self(sprintf('Entity "%s" not configured as part of the second-level cache.', $entityName));
+    }
+
+    /**
+     * @param string $entityName
+     * @param string $field
+     *
+     * @return CacheException
+     */
+    public static function nonCacheableEntityAssociation($entityName, $field)
+    {
+        return new self(sprintf('Entity association field "%s#%s" not configured as part of the second-level cache.', $entityName, $field));
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CacheFactory.php

@@ -0,0 +1,112 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\Persisters\Entity\EntityPersister;
+
+/**
+ * Contract for building second level cache regions components.
+ * 
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface CacheFactory
+{
+    /**
+     * Build an entity persister for the given entity metadata.
+     *
+     * @param \Doctrine\ORM\EntityManagerInterface            $em        The entity manager.
+     * @param \Doctrine\ORM\Persisters\Entity\EntityPersister $persister The entity persister that will be cached.
+     * @param \Doctrine\ORM\Mapping\ClassMetadata             $metadata  The entity metadata.
+     *
+     * @return \Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister
+     */
+    public function buildCachedEntityPersister(EntityManagerInterface $em, EntityPersister $persister, ClassMetadata $metadata);
+
+    /**
+     * Build a collection persister for the given relation mapping.
+     *
+     * @param \Doctrine\ORM\EntityManagerInterface                    $em        The entity manager.
+     * @param \Doctrine\ORM\Persisters\Collection\CollectionPersister $persister The collection persister that will be cached.
+     * @param array                                                   $mapping   The association mapping.
+     *
+     * @return \Doctrine\ORM\Cache\Persister\Collection\CachedCollectionPersister
+     */
+    public function buildCachedCollectionPersister(EntityManagerInterface $em, CollectionPersister $persister, array $mapping);
+
+    /**
+     * Build a query cache based on the given region name
+     *
+     * @param \Doctrine\ORM\EntityManagerInterface $em         The Entity manager.
+     * @param string                               $regionName The region name.
+     *
+     * @return \Doctrine\ORM\Cache\QueryCache The built query cache.
+     */
+    public function buildQueryCache(EntityManagerInterface $em, $regionName = null);
+
+    /**
+     * Build an entity hydrator
+     *
+     * @param \Doctrine\ORM\EntityManagerInterface $em       The Entity manager.
+     * @param \Doctrine\ORM\Mapping\ClassMetadata  $metadata The entity metadata.
+     *
+     * @return \Doctrine\ORM\Cache\EntityHydrator The built entity hydrator.
+     */
+    public function buildEntityHydrator(EntityManagerInterface $em, ClassMetadata $metadata);
+
+    /**
+     * Build a collection hydrator
+     *
+     * @param \Doctrine\ORM\EntityManagerInterface $em      The Entity manager.
+     * @param array                                $mapping The association mapping.
+     *
+     * @return \Doctrine\ORM\Cache\CollectionHydrator The built collection hydrator.
+     */
+    public function buildCollectionHydrator(EntityManagerInterface $em, array $mapping);
+
+    /**
+     * Build a cache region
+     *
+     * @param array $cache The cache configuration.
+     *
+     * @return \Doctrine\ORM\Cache\Region The cache region.
+     */
+    public function getRegion(array $cache);
+
+    /**
+     * Build timestamp cache region
+     *
+     * @return \Doctrine\ORM\Cache\TimestampRegion The timestamp region.
+     */
+    public function getTimestampRegion();
+
+    /**
+     * Build \Doctrine\ORM\Cache
+     *
+     * @param EntityManagerInterface $entityManager
+     *
+     * @return \Doctrine\ORM\Cache
+     */
+    public function createCache(EntityManagerInterface $entityManager);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CacheKey.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines entity / collection / query key to be stored in the cache region.
+ * Allows multiple roles to be stored in the same cache region.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+abstract class CacheKey
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var string Unique identifier
+     */
+    public $hash;
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CollectionCacheEntry.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Collection cache entry
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class CollectionCacheEntry implements CacheEntry
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var CacheKey[] The list of entity identifiers hold by the collection
+     */
+    public $identifiers;
+
+    /**
+     * @param CacheKey[] $identifiers List of entity identifiers hold by the collection
+     */
+    public function __construct(array $identifiers)
+    {
+        $this->identifiers = $identifiers;
+    }
+
+    /**
+     * Creates a new CollectionCacheEntry
+     *
+     * This method allows for Doctrine\Common\Cache\PhpFileCache compatibility
+     *
+     * @param array $values array containing property values
+     *
+     * @return CollectionCacheEntry
+     */
+    public static function __set_state(array $values)
+    {
+        return new self($values['identifiers']);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CollectionCacheKey.php

@@ -0,0 +1,66 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines entity collection roles to be stored in the cache region.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class CollectionCacheKey extends CacheKey
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var array The owner entity identifier
+     */
+    public $ownerIdentifier;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var string The owner entity class
+     */
+    public $entityClass;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var string The association name
+     */
+    public $association;
+
+    /**
+     * @param string $entityClass     The entity class.
+     * @param string $association     The field name that represents the association.
+     * @param array  $ownerIdentifier The identifier of the owning entity.
+     */
+    public function __construct($entityClass, $association, array $ownerIdentifier)
+    {
+        ksort($ownerIdentifier);
+
+        $this->ownerIdentifier  = $ownerIdentifier;
+        $this->entityClass      = (string) $entityClass;
+        $this->association      = (string) $association;
+        $this->hash             = str_replace('\\', '.', strtolower($entityClass)) . '_' . implode(' ', $ownerIdentifier) . '__' .  $association;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/CollectionHydrator.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+/**
+ * Hydrator cache entry for collections
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface CollectionHydrator
+{
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata           $metadata   The entity metadata.
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey        $key        The cached collection key.
+     * @param array|\Doctrine\Common\Collections\Collection $collection The collection.
+     *
+     * @return \Doctrine\ORM\Cache\CollectionCacheEntry
+     */
+    public function buildCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, $collection);
+
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata      $metadata   The owning entity metadata.
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey   $key        The cached collection key.
+     * @param \Doctrine\ORM\Cache\CollectionCacheEntry $entry      The cached collection entry.
+     * @param \Doctrine\ORM\PersistentCollection       $collection The collection to load the cache into.
+     *
+     * @return array
+     */
+    public function loadCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, CollectionCacheEntry $entry, PersistentCollection $collection);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/ConcurrentRegion.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines contract for concurrently managed data region.
+ * It should be able to lock an specific cache entry in an atomic operation.
+ *
+ * When a entry is locked another process should not be able to read or write the entry.
+ * All evict operation should not consider locks, even though an entry is locked evict should be able to delete the entry and its lock.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface ConcurrentRegion extends Region
+{
+    /**
+     * Attempts to read lock the mapping for the given key.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey $key The key of the item to lock.
+     *
+     * @return \Doctrine\ORM\Cache\Lock A lock instance or NULL if the lock already exists.
+     *
+     * @throws \Doctrine\ORM\Cache\LockException Indicates a problem accessing the region.
+     */
+    public function lock(CacheKey $key);
+
+    /**
+     * Attempts to read unlock the mapping for the given key.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey $key  The key of the item to unlock.
+     * @param \Doctrine\ORM\Cache\Lock     $lock The lock previously obtained from {@link readLock}
+     *
+     * @return void
+     *
+     * @throws \Doctrine\ORM\Cache\LockException Indicates a problem accessing the region.
+     */
+    public function unlock(CacheKey $key, Lock $lock);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/DefaultCache.php

@@ -0,0 +1,339 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Cache;
+use Doctrine\Common\Util\ClassUtils;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Cache\Persister\CachedPersister;
+use Doctrine\ORM\ORMInvalidArgumentException;
+
+/**
+ * Provides an API for querying/managing the second level cache regions.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultCache implements Cache
+{
+    /**
+     * @var \Doctrine\ORM\EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    private $uow;
+
+     /**
+     * @var \Doctrine\ORM\Cache\CacheFactory
+     */
+    private $cacheFactory;
+
+    /**
+     * @var \Doctrine\ORM\Cache\QueryCache[]
+     */
+    private $queryCaches = [];
+
+    /**
+     * @var \Doctrine\ORM\Cache\QueryCache
+     */
+    private $defaultQueryCache;
+
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em           = $em;
+        $this->uow          = $em->getUnitOfWork();
+        $this->cacheFactory = $em->getConfiguration()
+            ->getSecondLevelCacheConfiguration()
+            ->getCacheFactory();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getEntityCacheRegion($className)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getEntityPersister($metadata->rootEntityName);
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return null;
+        }
+
+        return $persister->getCacheRegion();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCollectionCacheRegion($className, $association)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return null;
+        }
+
+        return $persister->getCacheRegion();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function containsEntity($className, $identifier)
+    {
+        $metadata   = $this->em->getClassMetadata($className);
+        $persister  = $this->uow->getEntityPersister($metadata->rootEntityName);
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return false;
+        }
+
+        return $persister->getCacheRegion()->contains($this->buildEntityCacheKey($metadata, $identifier));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictEntity($className, $identifier)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getEntityPersister($metadata->rootEntityName);
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return;
+        }
+
+        $persister->getCacheRegion()->evict($this->buildEntityCacheKey($metadata, $identifier));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictEntityRegion($className)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getEntityPersister($metadata->rootEntityName);
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return;
+        }
+
+        $persister->getCacheRegion()->evictAll();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictEntityRegions()
+    {
+        $metadatas = $this->em->getMetadataFactory()->getAllMetadata();
+
+        foreach ($metadatas as $metadata) {
+            $persister = $this->uow->getEntityPersister($metadata->rootEntityName);
+
+            if ( ! ($persister instanceof CachedPersister)) {
+                continue;
+            }
+
+            $persister->getCacheRegion()->evictAll();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function containsCollection($className, $association, $ownerIdentifier)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return false;
+        }
+
+        return $persister->getCacheRegion()->contains($this->buildCollectionCacheKey($metadata, $association, $ownerIdentifier));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictCollection($className, $association, $ownerIdentifier)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return;
+        }
+
+        $persister->getCacheRegion()->evict($this->buildCollectionCacheKey($metadata, $association, $ownerIdentifier));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictCollectionRegion($className, $association)
+    {
+        $metadata  = $this->em->getClassMetadata($className);
+        $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));
+
+        if ( ! ($persister instanceof CachedPersister)) {
+            return;
+        }
+
+        $persister->getCacheRegion()->evictAll();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictCollectionRegions()
+    {
+        $metadatas = $this->em->getMetadataFactory()->getAllMetadata();
+
+        foreach ($metadatas as $metadata) {
+
+            foreach ($metadata->associationMappings as $association) {
+
+                if ( ! $association['type'] & ClassMetadata::TO_MANY) {
+                    continue;
+                }
+
+                $persister = $this->uow->getCollectionPersister($association);
+
+                if ( ! ($persister instanceof CachedPersister)) {
+                    continue;
+                }
+
+                $persister->getCacheRegion()->evictAll();
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function containsQuery($regionName)
+    {
+        return isset($this->queryCaches[$regionName]);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictQueryRegion($regionName = null)
+    {
+        if ($regionName === null && $this->defaultQueryCache !== null) {
+            $this->defaultQueryCache->clear();
+
+            return;
+        }
+
+        if (isset($this->queryCaches[$regionName])) {
+            $this->queryCaches[$regionName]->clear();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictQueryRegions()
+    {
+        $this->getQueryCache()->clear();
+
+        foreach ($this->queryCaches as $queryCache) {
+            $queryCache->clear();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getQueryCache($regionName = null)
+    {
+        if ($regionName === null) {
+            return $this->defaultQueryCache ?:
+                $this->defaultQueryCache = $this->cacheFactory->buildQueryCache($this->em);
+        }
+
+        if ( ! isset($this->queryCaches[$regionName])) {
+            $this->queryCaches[$regionName] = $this->cacheFactory->buildQueryCache($this->em, $regionName);
+        }
+
+        return $this->queryCaches[$regionName];
+    }
+
+     /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata   The entity metadata.
+     * @param mixed                               $identifier The entity identifier.
+     *
+     * @return \Doctrine\ORM\Cache\EntityCacheKey
+     */
+    private function buildEntityCacheKey(ClassMetadata $metadata, $identifier)
+    {
+        if ( ! is_array($identifier)) {
+            $identifier = $this->toIdentifierArray($metadata, $identifier);
+        }
+
+        return new EntityCacheKey($metadata->rootEntityName, $identifier);
+    }
+
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata        The entity metadata.
+     * @param string                              $association     The field name that represents the association.
+     * @param mixed                               $ownerIdentifier The identifier of the owning entity.
+     *
+     * @return \Doctrine\ORM\Cache\CollectionCacheKey
+     */
+    private function buildCollectionCacheKey(ClassMetadata $metadata, $association, $ownerIdentifier)
+    {
+        if ( ! is_array($ownerIdentifier)) {
+            $ownerIdentifier = $this->toIdentifierArray($metadata, $ownerIdentifier);
+        }
+
+        return new CollectionCacheKey($metadata->rootEntityName, $association, $ownerIdentifier);
+    }
+
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata   The entity metadata.
+     * @param mixed                               $identifier The entity identifier.
+     *
+     * @return array
+     */
+    private function toIdentifierArray(ClassMetadata $metadata, $identifier)
+    {
+        if (is_object($identifier) && $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($identifier))) {
+            $identifier = $this->uow->getSingleIdentifierValue($identifier);
+
+            if ($identifier === null) {
+                throw ORMInvalidArgumentException::invalidIdentifierBindingEntity();
+            }
+        }
+
+        return [$metadata->identifier[0] => $identifier];
+    }
+
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/DefaultCacheFactory.php

@@ -0,0 +1,275 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\Common\Cache\Cache as CacheAdapter;
+use Doctrine\Common\Cache\CacheProvider;
+use Doctrine\Common\Cache\MultiGetCache;
+use Doctrine\ORM\Cache;
+use Doctrine\ORM\Cache\Persister\Collection\NonStrictReadWriteCachedCollectionPersister;
+use Doctrine\ORM\Cache\Persister\Collection\ReadOnlyCachedCollectionPersister;
+use Doctrine\ORM\Cache\Persister\Collection\ReadWriteCachedCollectionPersister;
+use Doctrine\ORM\Cache\Persister\Entity\NonStrictReadWriteCachedEntityPersister;
+use Doctrine\ORM\Cache\Persister\Entity\ReadOnlyCachedEntityPersister;
+use Doctrine\ORM\Cache\Persister\Entity\ReadWriteCachedEntityPersister;
+use Doctrine\ORM\Cache\Region\DefaultMultiGetRegion;
+use Doctrine\ORM\Cache\Region\DefaultRegion;
+use Doctrine\ORM\Cache\Region\FileLockRegion;
+use Doctrine\ORM\Cache\Region\UpdateTimestampCache;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\Persisters\Entity\EntityPersister;
+
+/**
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultCacheFactory implements CacheFactory
+{
+    /**
+     * @var CacheAdapter
+     */
+    private $cache;
+
+    /**
+     * @var \Doctrine\ORM\Cache\RegionsConfiguration
+     */
+    private $regionsConfig;
+
+    /**
+     * @var \Doctrine\ORM\Cache\TimestampRegion|null
+     */
+    private $timestampRegion;
+
+    /**
+     * @var \Doctrine\ORM\Cache\Region[]
+     */
+    private $regions = [];
+
+    /**
+     * @var string|null
+     */
+    private $fileLockRegionDirectory;
+
+    /**
+     * @param RegionsConfiguration $cacheConfig
+     * @param CacheAdapter         $cache
+     */
+    public function __construct(RegionsConfiguration $cacheConfig, CacheAdapter $cache)
+    {
+        $this->cache         = $cache;
+        $this->regionsConfig = $cacheConfig;
+    }
+
+    /**
+     * @param string $fileLockRegionDirectory
+     */
+    public function setFileLockRegionDirectory($fileLockRegionDirectory)
+    {
+        $this->fileLockRegionDirectory = (string) $fileLockRegionDirectory;
+    }
+
+    /**
+     * @return string
+     */
+    public function getFileLockRegionDirectory()
+    {
+        return $this->fileLockRegionDirectory;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\Region $region
+     */
+    public function setRegion(Region $region)
+    {
+        $this->regions[$region->getName()] = $region;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\TimestampRegion $region
+     */
+    public function setTimestampRegion(TimestampRegion $region)
+    {
+        $this->timestampRegion = $region;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildCachedEntityPersister(EntityManagerInterface $em, EntityPersister $persister, ClassMetadata $metadata)
+    {
+        $region     = $this->getRegion($metadata->cache);
+        $usage      = $metadata->cache['usage'];
+
+        if ($usage === ClassMetadata::CACHE_USAGE_READ_ONLY) {
+            return new ReadOnlyCachedEntityPersister($persister, $region, $em, $metadata);
+        }
+
+        if ($usage === ClassMetadata::CACHE_USAGE_NONSTRICT_READ_WRITE) {
+            return new NonStrictReadWriteCachedEntityPersister($persister, $region, $em, $metadata);
+        }
+
+        if ($usage === ClassMetadata::CACHE_USAGE_READ_WRITE) {
+            return new ReadWriteCachedEntityPersister($persister, $region, $em, $metadata);
+        }
+
+        throw new \InvalidArgumentException(sprintf("Unrecognized access strategy type [%s]", $usage));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildCachedCollectionPersister(EntityManagerInterface $em, CollectionPersister $persister, array $mapping)
+    {
+        $usage      = $mapping['cache']['usage'];
+        $region     = $this->getRegion($mapping['cache']);
+
+        if ($usage === ClassMetadata::CACHE_USAGE_READ_ONLY) {
+            return new ReadOnlyCachedCollectionPersister($persister, $region, $em, $mapping);
+        }
+
+        if ($usage === ClassMetadata::CACHE_USAGE_NONSTRICT_READ_WRITE) {
+            return new NonStrictReadWriteCachedCollectionPersister($persister, $region, $em, $mapping);
+        }
+
+        if ($usage === ClassMetadata::CACHE_USAGE_READ_WRITE) {
+            return new ReadWriteCachedCollectionPersister($persister, $region, $em, $mapping);
+        }
+
+        throw new \InvalidArgumentException(sprintf("Unrecognized access strategy type [%s]", $usage));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildQueryCache(EntityManagerInterface $em, $regionName = null)
+    {
+        return new DefaultQueryCache(
+            $em,
+            $this->getRegion(
+                [
+                    'region' => $regionName ?: Cache::DEFAULT_QUERY_REGION_NAME,
+                    'usage'  => ClassMetadata::CACHE_USAGE_NONSTRICT_READ_WRITE
+                ]
+            )
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildCollectionHydrator(EntityManagerInterface $em, array $mapping)
+    {
+        return new DefaultCollectionHydrator($em);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildEntityHydrator(EntityManagerInterface $em, ClassMetadata $metadata)
+    {
+        return new DefaultEntityHydrator($em);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getRegion(array $cache)
+    {
+        if (isset($this->regions[$cache['region']])) {
+            return $this->regions[$cache['region']];
+        }
+
+        $name         = $cache['region'];
+        $cacheAdapter = $this->createRegionCache($name);
+        $lifetime     = $this->regionsConfig->getLifetime($cache['region']);
+
+        $region = ($cacheAdapter instanceof MultiGetCache)
+            ? new DefaultMultiGetRegion($name, $cacheAdapter, $lifetime)
+            : new DefaultRegion($name, $cacheAdapter, $lifetime);
+
+        if ($cache['usage'] === ClassMetadata::CACHE_USAGE_READ_WRITE) {
+
+            if (
+                '' === $this->fileLockRegionDirectory ||
+                null === $this->fileLockRegionDirectory
+            ) {
+                throw new \LogicException(
+                    'If you want to use a "READ_WRITE" cache an implementation of "Doctrine\ORM\Cache\ConcurrentRegion" is required, ' .
+                    'The default implementation provided by doctrine is "Doctrine\ORM\Cache\Region\FileLockRegion" if you want to use it please provide a valid directory, DefaultCacheFactory#setFileLockRegionDirectory(). '
+                );
+            }
+
+            $directory = $this->fileLockRegionDirectory . DIRECTORY_SEPARATOR . $cache['region'];
+            $region    = new FileLockRegion($region, $directory, $this->regionsConfig->getLockLifetime($cache['region']));
+        }
+
+        return $this->regions[$cache['region']] = $region;
+    }
+
+    /**
+     * @param string $name
+     *
+     * @return CacheAdapter
+     */
+    private function createRegionCache($name)
+    {
+        $cacheAdapter = clone $this->cache;
+
+        if (!$cacheAdapter instanceof CacheProvider) {
+            return $cacheAdapter;
+        }
+
+        $namespace = $cacheAdapter->getNamespace();
+
+        if ('' !== $namespace) {
+            $namespace .= ':';
+        }
+
+        $cacheAdapter->setNamespace($namespace . $name);
+
+        return $cacheAdapter;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTimestampRegion()
+    {
+        if ($this->timestampRegion === null) {
+            $name     = Cache::DEFAULT_TIMESTAMP_REGION_NAME;
+            $lifetime = $this->regionsConfig->getLifetime($name);
+
+            $this->timestampRegion = new UpdateTimestampCache($name, clone $this->cache, $lifetime);
+        }
+
+        return $this->timestampRegion;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createCache(EntityManagerInterface $em)
+    {
+        return new DefaultCache($em);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/DefaultCollectionHydrator.php

@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Query;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Default hydrator cache for collections
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultCollectionHydrator implements CollectionHydrator
+{
+    /**
+     * @var \Doctrine\ORM\EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    private $uow;
+
+    /**
+     * @var array
+     */
+    private static $hints = [Query::HINT_CACHE_ENABLED => true];
+
+    /**
+     * @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em  = $em;
+        $this->uow = $em->getUnitOfWork();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, $collection)
+    {
+        $data = [];
+
+        foreach ($collection as $index => $entity) {
+            $data[$index] = new EntityCacheKey($metadata->rootEntityName, $this->uow->getEntityIdentifier($entity));
+        }
+
+        return new CollectionCacheEntry($data);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, CollectionCacheEntry $entry, PersistentCollection $collection)
+    {
+        $assoc           = $metadata->associationMappings[$key->association];
+        /* @var $targetPersister \Doctrine\ORM\Cache\Persister\CachedPersister */
+        $targetPersister = $this->uow->getEntityPersister($assoc['targetEntity']);
+        $targetRegion    = $targetPersister->getCacheRegion();
+        $list            = [];
+
+        $entityEntries = $targetRegion->getMultiple($entry);
+
+        if ($entityEntries === null) {
+            return null;
+        }
+
+        /* @var $entityEntries \Doctrine\ORM\Cache\EntityCacheEntry[] */
+        foreach ($entityEntries as $index => $entityEntry) {
+            $list[$index] = $this->uow->createEntity($entityEntry->class, $entityEntry->resolveAssociationEntries($this->em), self::$hints);
+        }
+
+        array_walk($list, function($entity, $index) use ($collection) {
+            $collection->hydrateSet($index, $entity);
+        });
+
+        $this->uow->hydrationComplete();
+
+        return $list;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/DefaultEntityHydrator.php

@@ -0,0 +1,205 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\Common\Util\ClassUtils;
+
+use Doctrine\ORM\Query;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Utility\IdentifierFlattener;
+
+/**
+ * Default hydrator cache for entities
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultEntityHydrator implements EntityHydrator
+{
+    /**
+     * @var \Doctrine\ORM\EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    private $uow;
+
+    /**
+     * The IdentifierFlattener used for manipulating identifiers
+     *
+     * @var \Doctrine\ORM\Utility\IdentifierFlattener
+     */
+    private $identifierFlattener;
+
+    /**
+     * @var array
+     */
+    private static $hints = [Query::HINT_CACHE_ENABLED => true];
+
+    /**
+     * @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em   = $em;
+        $this->uow  = $em->getUnitOfWork();
+        $this->identifierFlattener = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function buildCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, $entity)
+    {
+        $data = $this->uow->getOriginalEntityData($entity);
+        $data = array_merge($data, $metadata->getIdentifierValues($entity)); // why update has no identifier values ?
+
+        if ($metadata->isVersioned) {
+            $data[$metadata->versionField] = $metadata->getFieldValue($entity, $metadata->versionField);
+        }
+
+        foreach ($metadata->associationMappings as $name => $assoc) {
+            if ( ! isset($data[$name])) {
+                continue;
+            }
+
+            if ( ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
+                unset($data[$name]);
+
+                continue;
+            }
+
+            if ( ! isset($assoc['cache'])) {
+                $targetClassMetadata = $this->em->getClassMetadata($assoc['targetEntity']);
+                $owningAssociation   = ( ! $assoc['isOwningSide'])
+                    ? $targetClassMetadata->associationMappings[$assoc['mappedBy']]
+                    : $assoc;
+                $associationIds      = $this->identifierFlattener->flattenIdentifier(
+                    $targetClassMetadata,
+                    $targetClassMetadata->getIdentifierValues($data[$name])
+                );
+
+                unset($data[$name]);
+
+                foreach ($associationIds as $fieldName => $fieldValue) {
+                    if (isset($targetClassMetadata->fieldMappings[$fieldName])) {
+                        $fieldMapping = $targetClassMetadata->fieldMappings[$fieldName];
+
+                        $data[$owningAssociation['targetToSourceKeyColumns'][$fieldMapping['columnName']]] = $fieldValue;
+
+                        continue;
+                    }
+
+                    $targetAssoc = $targetClassMetadata->associationMappings[$fieldName];
+
+                    foreach($assoc['targetToSourceKeyColumns'] as $referencedColumn => $localColumn) {
+                        if (isset($targetAssoc['sourceToTargetKeyColumns'][$referencedColumn])) {
+                            $data[$localColumn] = $fieldValue;
+                        }
+                    }
+                }
+
+                continue;
+            }
+
+            if ( ! isset($assoc['id'])) {
+                $targetClass = ClassUtils::getClass($data[$name]);
+                $targetId    = $this->uow->getEntityIdentifier($data[$name]);
+                $data[$name] = new AssociationCacheEntry($targetClass, $targetId);
+
+                continue;
+            }
+
+            // handle association identifier
+            $targetId = is_object($data[$name]) && $this->uow->isInIdentityMap($data[$name])
+                ? $this->uow->getEntityIdentifier($data[$name])
+                : $data[$name];
+
+            // @TODO - fix it !
+            // handle UnitOfWork#createEntity hash generation
+            if ( ! is_array($targetId)) {
+                $data[reset($assoc['joinColumnFieldNames'])] = $targetId;
+
+                $targetEntity = $this->em->getClassMetadata($assoc['targetEntity']);
+                $targetId     = [$targetEntity->identifier[0] => $targetId];
+            }
+
+            $data[$name] = new AssociationCacheEntry($assoc['targetEntity'], $targetId);
+        }
+
+        return new EntityCacheEntry($metadata->name, $data);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, EntityCacheEntry $entry, $entity = null)
+    {
+        $data  = $entry->data;
+        $hints = self::$hints;
+
+        if ($entity !== null) {
+            $hints[Query::HINT_REFRESH]         = true;
+            $hints[Query::HINT_REFRESH_ENTITY]  = $entity;
+        }
+
+        foreach ($metadata->associationMappings as $name => $assoc) {
+            if ( ! isset($assoc['cache']) ||  ! isset($data[$name])) {
+                continue;
+            }
+
+            $assocClass     = $data[$name]->class;
+            $assocId        = $data[$name]->identifier;
+            $isEagerLoad    = ($assoc['fetch'] === ClassMetadata::FETCH_EAGER || ($assoc['type'] === ClassMetadata::ONE_TO_ONE && ! $assoc['isOwningSide']));
+
+            if ( ! $isEagerLoad) {
+                $data[$name] = $this->em->getReference($assocClass, $assocId);
+
+                continue;
+            }
+
+            $assocMetadata  = $this->em->getClassMetadata($assoc['targetEntity']);
+            $assocKey       = new EntityCacheKey($assocMetadata->rootEntityName, $assocId);
+            $assocPersister = $this->uow->getEntityPersister($assoc['targetEntity']);
+            $assocRegion    = $assocPersister->getCacheRegion();
+            $assocEntry     = $assocRegion->get($assocKey);
+
+            if ($assocEntry === null) {
+                return null;
+            }
+
+            $data[$name] = $this->uow->createEntity($assocEntry->class, $assocEntry->resolveAssociationEntries($this->em), $hints);
+        }
+
+        if ($entity !== null) {
+            $this->uow->registerManaged($entity, $key->identifier, $data);
+        }
+
+        $result = $this->uow->createEntity($entry->class, $data, $hints);
+
+        $this->uow->hydrationComplete();
+
+        return $result;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/DefaultQueryCache.php

@@ -0,0 +1,483 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\ORM\Cache\Persister\CachedPersister;
+use Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Query\ResultSetMapping;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\Common\Proxy\Proxy;
+use Doctrine\ORM\Cache;
+use Doctrine\ORM\Query;
+use function assert;
+
+/**
+ * Default query cache implementation.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultQueryCache implements QueryCache
+{
+     /**
+     * @var \Doctrine\ORM\EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    private $uow;
+
+    /**
+     * @var \Doctrine\ORM\Cache\Region
+     */
+    private $region;
+
+    /**
+     * @var \Doctrine\ORM\Cache\QueryCacheValidator
+     */
+    private $validator;
+
+    /**
+     * @var \Doctrine\ORM\Cache\Logging\CacheLogger
+     */
+    protected $cacheLogger;
+
+    /**
+     * @var array
+     */
+    private static $hints = [Query::HINT_CACHE_ENABLED => true];
+
+    /**
+     * @param \Doctrine\ORM\EntityManagerInterface $em     The entity manager.
+     * @param \Doctrine\ORM\Cache\Region           $region The query region.
+     */
+    public function __construct(EntityManagerInterface $em, Region $region)
+    {
+        $cacheConfig = $em->getConfiguration()->getSecondLevelCacheConfiguration();
+
+        $this->em           = $em;
+        $this->region       = $region;
+        $this->uow          = $em->getUnitOfWork();
+        $this->cacheLogger  = $cacheConfig->getCacheLogger();
+        $this->validator    = $cacheConfig->getQueryValidator();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get(QueryCacheKey $key, ResultSetMapping $rsm, array $hints = [])
+    {
+        if ( ! ($key->cacheMode & Cache::MODE_GET)) {
+            return null;
+        }
+
+        $cacheEntry = $this->region->get($key);
+
+        if ( ! $cacheEntry instanceof QueryCacheEntry) {
+            return null;
+        }
+
+        if ( ! $this->validator->isValid($key, $cacheEntry)) {
+            $this->region->evict($key);
+
+            return null;
+        }
+
+        $result      = [];
+        $entityName  = reset($rsm->aliasMap);
+        $hasRelation = ! empty($rsm->relationMap);
+        $persister   = $this->uow->getEntityPersister($entityName);
+        assert($persister instanceof CachedEntityPersister);
+
+        $region     = $persister->getCacheRegion();
+        $regionName = $region->getName();
+
+        $cm = $this->em->getClassMetadata($entityName);
+
+        $generateKeys = static function (array $entry) use ($cm) : EntityCacheKey {
+            return new EntityCacheKey($cm->rootEntityName, $entry['identifier']);
+        };
+
+        $cacheKeys = new CollectionCacheEntry(array_map($generateKeys, $cacheEntry->result));
+        $entries   = $region->getMultiple($cacheKeys) ?? [];
+
+        // @TODO - move to cache hydration component
+        foreach ($cacheEntry->result as $index => $entry) {
+            $entityEntry = $entries[$index] ?? null;
+
+            if (! $entityEntry instanceof EntityCacheEntry) {
+                if ($this->cacheLogger !== null) {
+                    $this->cacheLogger->entityCacheMiss($regionName, $cacheKeys->identifiers[$index]);
+                }
+
+                return null;
+            }
+
+            if ($this->cacheLogger !== null) {
+                $this->cacheLogger->entityCacheHit($regionName, $cacheKeys->identifiers[$index]);
+            }
+
+            if ( ! $hasRelation) {
+                $result[$index]  = $this->uow->createEntity($entityEntry->class, $entityEntry->resolveAssociationEntries($this->em), self::$hints);
+
+                continue;
+            }
+
+            $data = $entityEntry->data;
+
+            foreach ($entry['associations'] as $name => $assoc) {
+                $assocPersister = $this->uow->getEntityPersister($assoc['targetEntity']);
+                assert($assocPersister instanceof CachedEntityPersister);
+
+                $assocRegion   = $assocPersister->getCacheRegion();
+                $assocMetadata = $this->em->getClassMetadata($assoc['targetEntity']);
+
+                if ($assoc['type'] & ClassMetadata::TO_ONE) {
+
+                    if (($assocEntry = $assocRegion->get($assocKey = new EntityCacheKey($assocMetadata->rootEntityName, $assoc['identifier']))) === null) {
+
+                        if ($this->cacheLogger !== null) {
+                            $this->cacheLogger->entityCacheMiss($assocRegion->getName(), $assocKey);
+                        }
+
+                        $this->uow->hydrationComplete();
+
+                        return null;
+                    }
+
+                    $data[$name] = $this->uow->createEntity($assocEntry->class, $assocEntry->resolveAssociationEntries($this->em), self::$hints);
+
+                    if ($this->cacheLogger !== null) {
+                        $this->cacheLogger->entityCacheHit($assocRegion->getName(), $assocKey);
+                    }
+
+                    continue;
+                }
+
+                if ( ! isset($assoc['list']) || empty($assoc['list'])) {
+                    continue;
+                }
+
+                $generateKeys = function ($id) use ($assocMetadata): EntityCacheKey {
+                    return new EntityCacheKey($assocMetadata->rootEntityName, $id);
+                };
+
+                $collection   = new PersistentCollection($this->em, $assocMetadata, new ArrayCollection());
+                $assocKeys    = new CollectionCacheEntry(array_map($generateKeys, $assoc['list']));
+                $assocEntries = $assocRegion->getMultiple($assocKeys);
+
+                foreach ($assoc['list'] as $assocIndex => $assocId) {
+                    $assocEntry = is_array($assocEntries) && array_key_exists($assocIndex, $assocEntries) ? $assocEntries[$assocIndex] : null;
+
+                    if ($assocEntry === null) {
+                        if ($this->cacheLogger !== null) {
+                            $this->cacheLogger->entityCacheMiss($assocRegion->getName(), $assocKeys->identifiers[$assocIndex]);
+                        }
+
+                        $this->uow->hydrationComplete();
+
+                        return null;
+                    }
+
+                    $element = $this->uow->createEntity($assocEntry->class, $assocEntry->resolveAssociationEntries($this->em), self::$hints);
+
+                    $collection->hydrateSet($assocIndex, $element);
+
+                    if ($this->cacheLogger !== null) {
+                        $this->cacheLogger->entityCacheHit($assocRegion->getName(), $assocKeys->identifiers[$assocIndex]);
+                    }
+                }
+
+                $data[$name] = $collection;
+
+                $collection->setInitialized(true);
+            }
+
+            foreach ($data as $fieldName => $unCachedAssociationData) {
+                // In some scenarios, such as EAGER+ASSOCIATION+ID+CACHE, the
+                // cache key information in `$cacheEntry` will not contain details
+                // for fields that are associations.
+                //
+                // This means that `$data` keys for some associations that may
+                // actually not be cached will not be converted to actual association
+                // data, yet they contain L2 cache AssociationCacheEntry objects.
+                //
+                // We need to unwrap those associations into proxy references,
+                // since we don't have actual data for them except for identifiers.
+                if ($unCachedAssociationData instanceof AssociationCacheEntry) {
+                    $data[$fieldName] = $this->em->getReference(
+                        $unCachedAssociationData->class,
+                        $unCachedAssociationData->identifier
+                    );
+                }
+            }
+
+            $result[$index] = $this->uow->createEntity($entityEntry->class, $data, self::$hints);
+        }
+
+        $this->uow->hydrationComplete();
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function put(QueryCacheKey $key, ResultSetMapping $rsm, $result, array $hints = [])
+    {
+        if ($rsm->scalarMappings) {
+            throw new CacheException("Second level cache does not support scalar results.");
+        }
+
+        if (count($rsm->entityMappings) > 1) {
+            throw new CacheException("Second level cache does not support multiple root entities.");
+        }
+
+        if ( ! $rsm->isSelect) {
+            throw new CacheException("Second-level cache query supports only select statements.");
+        }
+
+        if (($hints[Query\SqlWalker::HINT_PARTIAL] ?? false) === true || ($hints[Query::HINT_FORCE_PARTIAL_LOAD] ?? false) === true) {
+            throw new CacheException("Second level cache does not support partial entities.");
+        }
+
+        if ( ! ($key->cacheMode & Cache::MODE_PUT)) {
+            return false;
+        }
+
+        $data        = [];
+        $entityName  = reset($rsm->aliasMap);
+        $rootAlias   = key($rsm->aliasMap);
+        $persister   = $this->uow->getEntityPersister($entityName);
+
+        if (! $persister instanceof CachedEntityPersister) {
+            throw CacheException::nonCacheableEntity($entityName);
+        }
+
+        $region = $persister->getCacheRegion();
+
+        $cm = $this->em->getClassMetadata($entityName);
+        assert($cm instanceof ClassMetadata);
+
+        foreach ($result as $index => $entity) {
+            $identifier = $this->uow->getEntityIdentifier($entity);
+            $entityKey  = new EntityCacheKey($cm->rootEntityName, $identifier);
+
+            if (($key->cacheMode & Cache::MODE_REFRESH) || ! $region->contains($entityKey)) {
+                // Cancel put result if entity put fail
+                if ( ! $persister->storeEntityCache($entity, $entityKey)) {
+                    return false;
+                }
+            }
+
+            $data[$index]['identifier']   = $identifier;
+            $data[$index]['associations'] = [];
+
+            // @TODO - move to cache hydration components
+            foreach ($rsm->relationMap as $alias => $name) {
+                $parentAlias  = $rsm->parentAliasMap[$alias];
+                $parentClass  = $rsm->aliasMap[$parentAlias];
+                $metadata     = $this->em->getClassMetadata($parentClass);
+                $assoc        = $metadata->associationMappings[$name];
+                $assocValue   = $this->getAssociationValue($rsm, $alias, $entity);
+
+                if ($assocValue === null) {
+                    continue;
+                }
+
+                // root entity association
+                if ($rootAlias === $parentAlias) {
+                    // Cancel put result if association put fail
+                    if ( ($assocInfo = $this->storeAssociationCache($key, $assoc, $assocValue)) === null) {
+                        return false;
+                    }
+
+                    $data[$index]['associations'][$name] = $assocInfo;
+
+                    continue;
+                }
+
+                // store single nested association
+                if ( ! is_array($assocValue)) {
+                    // Cancel put result if association put fail
+                    if ($this->storeAssociationCache($key, $assoc, $assocValue) === null) {
+                        return false;
+                    }
+
+                    continue;
+                }
+
+                // store array of nested association
+                foreach ($assocValue as $aVal) {
+                    // Cancel put result if association put fail
+                    if ($this->storeAssociationCache($key, $assoc, $aVal) === null) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return $this->region->put($key, new QueryCacheEntry($data));
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\QueryCacheKey $key
+     * @param array                             $assoc
+     * @param mixed                             $assocValue
+     *
+     * @return mixed[]|null
+     *
+     * @psalm-return array{targetEntity: string, type: mixed, list?: array[], identifier?: array}|null
+     */
+    private function storeAssociationCache(QueryCacheKey $key, array $assoc, $assocValue)
+    {
+        $assocPersister = $this->uow->getEntityPersister($assoc['targetEntity']);
+        $assocMetadata  = $assocPersister->getClassMetadata();
+        $assocRegion    = $assocPersister->getCacheRegion();
+
+        // Handle *-to-one associations
+        if ($assoc['type'] & ClassMetadata::TO_ONE) {
+            $assocIdentifier = $this->uow->getEntityIdentifier($assocValue);
+            $entityKey       = new EntityCacheKey($assocMetadata->rootEntityName, $assocIdentifier);
+
+            if ( ! $assocValue instanceof Proxy && ($key->cacheMode & Cache::MODE_REFRESH) || ! $assocRegion->contains($entityKey)) {
+                // Entity put fail
+                if ( ! $assocPersister->storeEntityCache($assocValue, $entityKey)) {
+                    return null;
+                }
+            }
+
+            return [
+                'targetEntity'  => $assocMetadata->rootEntityName,
+                'identifier'    => $assocIdentifier,
+                'type'          => $assoc['type']
+            ];
+        }
+
+        // Handle *-to-many associations
+        $list = [];
+
+        foreach ($assocValue as $assocItemIndex => $assocItem) {
+            $assocIdentifier = $this->uow->getEntityIdentifier($assocItem);
+            $entityKey       = new EntityCacheKey($assocMetadata->rootEntityName, $assocIdentifier);
+
+            if (($key->cacheMode & Cache::MODE_REFRESH) || ! $assocRegion->contains($entityKey)) {
+                // Entity put fail
+                if ( ! $assocPersister->storeEntityCache($assocItem, $entityKey)) {
+                    return null;
+                }
+            }
+
+            $list[$assocItemIndex] = $assocIdentifier;
+        }
+
+        return [
+            'targetEntity'  => $assocMetadata->rootEntityName,
+            'type'          => $assoc['type'],
+            'list'          => $list,
+        ];
+    }
+
+    /**
+     * @param \Doctrine\ORM\Query\ResultSetMapping $rsm
+     * @param string                               $assocAlias
+     * @param object                               $entity
+     *
+     * @return array|object
+     */
+    private function getAssociationValue(ResultSetMapping $rsm, $assocAlias, $entity)
+    {
+        $path  = [];
+        $alias = $assocAlias;
+
+        while (isset($rsm->parentAliasMap[$alias])) {
+            $parent = $rsm->parentAliasMap[$alias];
+            $field  = $rsm->relationMap[$alias];
+            $class  = $rsm->aliasMap[$parent];
+
+            array_unshift($path, [
+                'field'  => $field,
+                'class'  => $class
+            ]
+            );
+
+            $alias = $parent;
+        }
+
+        return $this->getAssociationPathValue($entity, $path);
+    }
+
+    /**
+     * @param mixed $value
+     * @param array $path
+     *
+     * @return array|object|null
+     */
+    private function getAssociationPathValue($value, array $path)
+    {
+        $mapping  = array_shift($path);
+        $metadata = $this->em->getClassMetadata($mapping['class']);
+        $assoc    = $metadata->associationMappings[$mapping['field']];
+        $value    = $metadata->getFieldValue($value, $mapping['field']);
+
+        if ($value === null) {
+            return null;
+        }
+
+        if (empty($path)) {
+            return $value;
+        }
+
+        // Handle *-to-one associations
+        if ($assoc['type'] & ClassMetadata::TO_ONE) {
+            return $this->getAssociationPathValue($value, $path);
+        }
+
+        $values = [];
+
+        foreach ($value as $item) {
+            $values[] = $this->getAssociationPathValue($item, $path);
+        }
+
+        return $values;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        return $this->region->evictAll();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getRegion()
+    {
+        return $this->region;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/EntityCacheEntry.php

@@ -0,0 +1,88 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Entity cache entry
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class EntityCacheEntry implements CacheEntry
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var array The entity map data
+     */
+    public $data;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var string The entity class name
+     */
+    public $class;
+
+    /**
+     * @param string $class The entity class.
+     * @param array  $data  The entity data.
+     */
+    public function __construct($class, array $data)
+    {
+        $this->class = $class;
+        $this->data  = $data;
+    }
+
+    /**
+     * Creates a new EntityCacheEntry
+     *
+     * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
+     *
+     * @param array $values array containing property values
+     *
+     * @return EntityCacheEntry
+     */
+    public static function __set_state(array $values)
+    {
+        return new self($values['class'], $values['data']);
+    }
+
+    /**
+     * Retrieves the entity data resolving cache entries
+     *
+     * @param \Doctrine\ORM\EntityManagerInterface $em
+     *
+     * @return array
+     */
+    public function resolveAssociationEntries(EntityManagerInterface $em)
+    {
+        return array_map(function($value) use ($em) {
+            if ( ! ($value instanceof AssociationCacheEntry)) {
+                return $value;
+            }
+
+            return $em->getReference($value->class, $value->identifier);
+        }, $this->data);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/EntityCacheKey.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines entity classes roles to be stored in the cache region.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class EntityCacheKey extends CacheKey
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var array The entity identifier
+     */
+    public $identifier;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var string The entity class name
+     */
+    public $entityClass;
+
+    /**
+     * @param string $entityClass The entity class name. In a inheritance hierarchy it should always be the root entity class.
+     * @param array  $identifier  The entity identifier
+     */
+    public function __construct($entityClass, array $identifier)
+    {
+        ksort($identifier);
+
+        $this->identifier  = $identifier;
+        $this->entityClass = $entityClass;
+        $this->hash        = str_replace('\\', '.', strtolower($entityClass) . '_' . implode(' ', $identifier));
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/EntityHydrator.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+/**
+ * Hydrator cache entry for entities
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface EntityHydrator
+{
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata The entity metadata.
+     * @param \Doctrine\ORM\Cache\EntityCacheKey  $key      The entity cache key.
+     * @param object                              $entity   The entity.
+     *
+     * @return \Doctrine\ORM\Cache\EntityCacheEntry
+     */
+    public function buildCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, $entity);
+
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadata  $metadata The entity metadata.
+     * @param \Doctrine\ORM\Cache\EntityCacheKey   $key      The entity cache key.
+     * @param \Doctrine\ORM\Cache\EntityCacheEntry $entry    The entity cache entry.
+     * @param object                               $entity   The entity to load the cache into. If not specified, a new entity is created.
+     */
+    public function loadCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, EntityCacheEntry $entry, $entity = null);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Lock.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Cache Lock
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class Lock
+{
+    /**
+     * @var string
+     */
+    public $value;
+
+    /**
+     * @var integer
+     */
+    public $time;
+
+    /**
+     * @param string  $value
+     * @param integer $time
+     */
+    public function __construct($value, $time = null)
+    {
+        $this->value = $value;
+        $this->time  = $time ? : time();
+    }
+
+    /**
+     * @return \Doctrine\ORM\Cache\Lock
+     */
+    public static function createLockRead()
+    {
+        return new self(uniqid(time(), true));
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/LockException.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Lock exception for cache.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class LockException extends CacheException
+{
+
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Logging/CacheLogger.php

@@ -0,0 +1,106 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Logging;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\EntityCacheKey;
+use Doctrine\ORM\Cache\QueryCacheKey;
+
+/**
+ * Interface for logging.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface CacheLogger
+{
+    /**
+     * Log an entity put into second level cache.
+     *
+     * @param string                             $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\EntityCacheKey $key        The cache key of the entity.
+     */
+    public function entityCachePut($regionName, EntityCacheKey $key);
+
+    /**
+     * Log an entity get from second level cache resulted in a hit.
+     *
+     * @param string                             $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\EntityCacheKey $key        The cache key of the entity.
+     */
+    public function entityCacheHit($regionName, EntityCacheKey $key);
+
+    /**
+     * Log an entity get from second level cache resulted in a miss.
+     *
+     * @param string                             $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\EntityCacheKey $key        The cache key of the entity.
+     */
+    public function entityCacheMiss($regionName, EntityCacheKey $key);
+
+     /**
+     * Log an entity put into second level cache.
+     *
+     * @param string                                 $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey $key        The cache key of the collection.
+     */
+    public function collectionCachePut($regionName, CollectionCacheKey $key);
+
+    /**
+     * Log an entity get from second level cache resulted in a hit.
+     *
+     * @param string                                 $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey $key        The cache key of the collection.
+     */
+    public function collectionCacheHit($regionName, CollectionCacheKey $key);
+
+    /**
+     * Log an entity get from second level cache resulted in a miss.
+     *
+     * @param string                                 $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey $key        The cache key of the collection.
+     */
+    public function collectionCacheMiss($regionName, CollectionCacheKey $key);
+
+    /**
+     * Log a query put into the query cache.
+     *
+     * @param string                            $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\QueryCacheKey $key        The cache key of the query.
+     */
+    public function queryCachePut($regionName, QueryCacheKey $key);
+
+    /**
+     * Log a query get from the query cache resulted in a hit.
+     *
+     * @param string                            $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\QueryCacheKey $key        The cache key of the query.
+     */
+    public function queryCacheHit($regionName, QueryCacheKey $key);
+
+    /**
+     * Log a query get from the query cache resulted in a miss.
+     *
+     * @param string                            $regionName The name of the cache region.
+     * @param \Doctrine\ORM\Cache\QueryCacheKey $key        The cache key of the query.
+     */
+    public function queryCacheMiss($regionName, QueryCacheKey $key);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Logging/CacheLoggerChain.php

@@ -0,0 +1,156 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Logging;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\EntityCacheKey;
+use Doctrine\ORM\Cache\QueryCacheKey;
+
+/**
+ * Cache logger chain
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class CacheLoggerChain implements CacheLogger
+{
+    /**
+     * @var array<\Doctrine\ORM\Cache\Logging\CacheLogger>
+     */
+    private $loggers = [];
+
+    /**
+     * @param string                                  $name
+     * @param \Doctrine\ORM\Cache\Logging\CacheLogger $logger
+     */
+    public function setLogger($name, CacheLogger $logger)
+    {
+        $this->loggers[$name] = $logger;
+    }
+
+    /**
+     * @param string $name
+     *
+     * @return \Doctrine\ORM\Cache\Logging\CacheLogger|null
+     */
+    public function getLogger($name)
+    {
+        return isset($this->loggers[$name]) ? $this->loggers[$name] : null;
+    }
+
+    /**
+     * @return array<\Doctrine\ORM\Cache\Logging\CacheLogger>
+     */
+    public function getLoggers()
+    {
+        return $this->loggers;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collectionCacheHit($regionName, CollectionCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->collectionCacheHit($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collectionCacheMiss($regionName, CollectionCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->collectionCacheMiss($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collectionCachePut($regionName, CollectionCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->collectionCachePut($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function entityCacheHit($regionName, EntityCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->entityCacheHit($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function entityCacheMiss($regionName, EntityCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->entityCacheMiss($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function entityCachePut($regionName, EntityCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->entityCachePut($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function queryCacheHit($regionName, QueryCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->queryCacheHit($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function queryCacheMiss($regionName, QueryCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->queryCacheMiss($regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function queryCachePut($regionName, QueryCacheKey $key)
+    {
+        foreach ($this->loggers as $logger) {
+            $logger->queryCachePut($regionName, $key);
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Logging/StatisticsCacheLogger.php

@@ -0,0 +1,251 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Logging;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\EntityCacheKey;
+use Doctrine\ORM\Cache\QueryCacheKey;
+
+/**
+ * Provide basic second level cache statistics.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class StatisticsCacheLogger implements CacheLogger
+{
+    /**
+     * @var int[]
+     */
+    private $cacheMissCountMap = [];
+
+    /**
+     * @var int[]
+     */
+    private $cacheHitCountMap = [];
+
+    /**
+     * @var int[]
+     */
+    private $cachePutCountMap = [];
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collectionCacheMiss($regionName, CollectionCacheKey $key)
+    {
+        $this->cacheMissCountMap[$regionName] = isset($this->cacheMissCountMap[$regionName])
+            ? $this->cacheMissCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collectionCacheHit($regionName, CollectionCacheKey $key)
+    {
+        $this->cacheHitCountMap[$regionName] = isset($this->cacheHitCountMap[$regionName])
+            ? $this->cacheHitCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collectionCachePut($regionName, CollectionCacheKey $key)
+    {
+        $this->cachePutCountMap[$regionName] = isset($this->cachePutCountMap[$regionName])
+            ? $this->cachePutCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function entityCacheMiss($regionName, EntityCacheKey $key)
+    {
+        $this->cacheMissCountMap[$regionName] = isset($this->cacheMissCountMap[$regionName])
+            ? $this->cacheMissCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function entityCacheHit($regionName, EntityCacheKey $key)
+    {
+        $this->cacheHitCountMap[$regionName] = isset($this->cacheHitCountMap[$regionName])
+            ? $this->cacheHitCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function entityCachePut($regionName, EntityCacheKey $key)
+    {
+        $this->cachePutCountMap[$regionName] = isset($this->cachePutCountMap[$regionName])
+            ? $this->cachePutCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function queryCacheHit($regionName, QueryCacheKey $key)
+    {
+        $this->cacheHitCountMap[$regionName] = isset($this->cacheHitCountMap[$regionName])
+            ? $this->cacheHitCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function queryCacheMiss($regionName, QueryCacheKey $key)
+    {
+        $this->cacheMissCountMap[$regionName] = isset($this->cacheMissCountMap[$regionName])
+            ? $this->cacheMissCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function queryCachePut($regionName, QueryCacheKey $key)
+    {
+        $this->cachePutCountMap[$regionName] = isset($this->cachePutCountMap[$regionName])
+            ? $this->cachePutCountMap[$regionName] + 1
+            : 1;
+    }
+
+    /**
+     * Get the number of entries successfully retrieved from cache.
+     *
+     * @param string $regionName The name of the cache region.
+     *
+     * @return int
+     */
+    public function getRegionHitCount($regionName)
+    {
+        return isset($this->cacheHitCountMap[$regionName]) ? $this->cacheHitCountMap[$regionName] : 0;
+    }
+
+    /**
+     * Get the number of cached entries *not* found in cache.
+     *
+     * @param string $regionName The name of the cache region.
+     *
+     * @return int
+     */
+    public function getRegionMissCount($regionName)
+    {
+        return isset($this->cacheMissCountMap[$regionName]) ? $this->cacheMissCountMap[$regionName] : 0;
+    }
+
+    /**
+     * Get the number of cacheable entries put in cache.
+     *
+     * @param string $regionName The name of the cache region.
+     *
+     * @return int
+     */
+    public function getRegionPutCount($regionName)
+    {
+        return isset($this->cachePutCountMap[$regionName]) ? $this->cachePutCountMap[$regionName] : 0;
+    }
+
+    /**
+     * @return array
+     */
+    public function getRegionsMiss()
+    {
+        return $this->cacheMissCountMap;
+    }
+
+    /**
+     * @return array
+     */
+    public function getRegionsHit()
+    {
+        return $this->cacheHitCountMap;
+    }
+
+    /**
+     * @return array
+     */
+    public function getRegionsPut()
+    {
+        return $this->cachePutCountMap;
+    }
+
+    /**
+     * Clear region statistics
+     *
+     * @param string $regionName The name of the cache region.
+     */
+    public function clearRegionStats($regionName)
+    {
+        $this->cachePutCountMap[$regionName]  = 0;
+        $this->cacheHitCountMap[$regionName]  = 0;
+        $this->cacheMissCountMap[$regionName] = 0;
+    }
+
+    /**
+     * Clear all statistics
+     */
+    public function clearStats()
+    {
+        $this->cachePutCountMap  = [];
+        $this->cacheHitCountMap  = [];
+        $this->cacheMissCountMap = [];
+    }
+
+    /**
+     * Get the total number of put in cache.
+     *
+     * @return int
+     */
+    public function getPutCount()
+    {
+        return array_sum($this->cachePutCountMap);
+    }
+
+    /**
+     * Get the total number of entries successfully retrieved from cache.
+     *
+     * @return int
+     */
+    public function getHitCount()
+    {
+        return array_sum($this->cacheHitCountMap);
+    }
+
+    /**
+     * Get the total number of cached entries *not* found in cache.
+     *
+     * @return int
+     */
+    public function getMissCount()
+    {
+        return array_sum($this->cacheMissCountMap);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/MultiGetRegion.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines a region that supports multi-get reading.
+ *
+ * With one method call we can get multiple items.
+ *
+ * @since   2.5
+ * @author  Asmir Mustafic
+ */
+interface MultiGetRegion
+{
+    /**
+     * Get all items from the cache identified by $keys.
+     * It returns NULL if some elements can not be found.
+     *
+     * @param CollectionCacheEntry $collection The collection of the items to be retrieved.
+     *
+     * @return CacheEntry[]|null The cached entries or NULL if one or more entries can not be found
+     */
+    public function getMultiple(CollectionCacheEntry $collection);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/CachedPersister.php

@@ -0,0 +1,46 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister;
+
+/**
+ * Interface for persister that support second level cache.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface CachedPersister
+{
+    /**
+     * Perform whatever processing is encapsulated here after completion of the transaction.
+     */
+    public function afterTransactionComplete();
+
+    /**
+     * Perform whatever processing is encapsulated here after completion of the rolled-back.
+     */
+    public function afterTransactionRolledBack();
+
+    /**
+     * Gets the The region access.
+     *
+     * @return \Doctrine\ORM\Cache\Region
+     */
+    public function getCacheRegion();
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Collection/AbstractCollectionPersister.php

@@ -0,0 +1,299 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\Common\Collections\Criteria;
+use Doctrine\ORM\Cache\EntityCacheKey;
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Cache\Region;
+use Doctrine\Common\Util\ClassUtils;
+
+/**
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @since 2.5
+ */
+abstract class AbstractCollectionPersister implements CachedCollectionPersister
+{
+     /**
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    protected $uow;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadataFactory
+     */
+    protected $metadataFactory;
+
+    /**
+     * @var \Doctrine\ORM\Persisters\Collection\CollectionPersister
+     */
+    protected $persister;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    protected $sourceEntity;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    protected $targetEntity;
+
+    /**
+     * @var array
+     */
+    protected $association;
+
+     /**
+     * @var array
+     */
+    protected $queuedCache = [];
+
+    /**
+     * @var \Doctrine\ORM\Cache\Region
+     */
+    protected $region;
+
+    /**
+     * @var string
+     */
+    protected $regionName;
+
+    /**
+     * @var \Doctrine\ORM\Cache\CollectionHydrator
+     */
+    protected $hydrator;
+
+    /**
+     * @var \Doctrine\ORM\Cache\Logging\CacheLogger
+     */
+    protected $cacheLogger;
+
+    /**
+     * @param \Doctrine\ORM\Persisters\Collection\CollectionPersister $persister   The collection persister that will be cached.
+     * @param \Doctrine\ORM\Cache\Region                              $region      The collection region.
+     * @param \Doctrine\ORM\EntityManagerInterface                    $em          The entity manager.
+     * @param array                                                   $association The association mapping.
+     */
+    public function __construct(CollectionPersister $persister, Region $region, EntityManagerInterface $em, array $association)
+    {
+        $configuration  = $em->getConfiguration();
+        $cacheConfig    = $configuration->getSecondLevelCacheConfiguration();
+        $cacheFactory   = $cacheConfig->getCacheFactory();
+
+        $this->region           = $region;
+        $this->persister        = $persister;
+        $this->association      = $association;
+        $this->regionName       = $region->getName();
+        $this->uow              = $em->getUnitOfWork();
+        $this->metadataFactory  = $em->getMetadataFactory();
+        $this->cacheLogger      = $cacheConfig->getCacheLogger();
+        $this->hydrator         = $cacheFactory->buildCollectionHydrator($em, $association);
+        $this->sourceEntity     = $em->getClassMetadata($association['sourceEntity']);
+        $this->targetEntity     = $em->getClassMetadata($association['targetEntity']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCacheRegion()
+    {
+        return $this->region;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSourceEntityMetadata()
+    {
+        return $this->sourceEntity;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTargetEntityMetadata()
+    {
+        return $this->targetEntity;
+    }
+
+    /**
+     * @param \Doctrine\ORM\PersistentCollection     $collection
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey $key
+     *
+     * @return object[]|null
+     */
+    public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key)
+    {
+        if (($cache = $this->region->get($key)) === null) {
+            return null;
+        }
+
+        if (($cache = $this->hydrator->loadCacheEntry($this->sourceEntity, $key, $cache, $collection)) === null) {
+            return null;
+        }
+
+        return $cache;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function storeCollectionCache(CollectionCacheKey $key, $elements)
+    {
+        /* @var $targetPersister CachedEntityPersister */
+        $associationMapping = $this->sourceEntity->associationMappings[$key->association];
+        $targetPersister    = $this->uow->getEntityPersister($this->targetEntity->rootEntityName);
+        $targetRegion       = $targetPersister->getCacheRegion();
+        $targetHydrator     = $targetPersister->getEntityHydrator();
+
+        // Only preserve ordering if association configured it
+        if ( ! (isset($associationMapping['indexBy']) && $associationMapping['indexBy'])) {
+            // Elements may be an array or a Collection
+            $elements = array_values(is_array($elements) ? $elements : $elements->getValues());
+        }
+
+        $entry = $this->hydrator->buildCacheEntry($this->targetEntity, $key, $elements);
+
+        foreach ($entry->identifiers as $index => $entityKey) {
+            if ($targetRegion->contains($entityKey)) {
+                continue;
+            }
+
+            $class      = $this->targetEntity;
+            $className  = ClassUtils::getClass($elements[$index]);
+
+            if ($className !== $this->targetEntity->name) {
+                $class = $this->metadataFactory->getMetadataFor($className);
+            }
+
+            $entity       = $elements[$index];
+            $entityEntry  = $targetHydrator->buildCacheEntry($class, $entityKey, $entity);
+
+            $targetRegion->put($entityKey, $entityEntry);
+        }
+
+        $cached = $this->region->put($key, $entry);
+
+        if ($this->cacheLogger && $cached) {
+            $this->cacheLogger->collectionCachePut($this->regionName, $key);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function contains(PersistentCollection $collection, $element)
+    {
+        return $this->persister->contains($collection, $element);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function containsKey(PersistentCollection $collection, $key)
+    {
+        return $this->persister->containsKey($collection, $key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function count(PersistentCollection $collection)
+    {
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
+        $entry   = $this->region->get($key);
+
+        if ($entry !== null) {
+            return count($entry->identifiers);
+        }
+
+        return $this->persister->count($collection);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get(PersistentCollection $collection, $index)
+    {
+        return $this->persister->get($collection, $index);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function slice(PersistentCollection $collection, $offset, $length = null)
+    {
+        return $this->persister->slice($collection, $offset, $length);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
+    {
+        return $this->persister->loadCriteria($collection, $criteria);
+    }
+
+    /**
+     * Clears cache entries related to the current collection
+     *
+     * @param PersistentCollection $collection
+     */
+    protected function evictCollectionCache(PersistentCollection $collection)
+    {
+        $key = new CollectionCacheKey(
+            $this->sourceEntity->rootEntityName,
+            $this->association['fieldName'],
+            $this->uow->getEntityIdentifier($collection->getOwner())
+        );
+
+        $this->region->evict($key);
+
+        if ($this->cacheLogger) {
+            $this->cacheLogger->collectionCachePut($this->regionName, $key);
+        }
+    }
+
+    /**
+     * @param string $targetEntity
+     * @param object $element
+     */
+    protected function evictElementCache($targetEntity, $element)
+    {
+        /* @var $targetPersister CachedEntityPersister */
+        $targetPersister = $this->uow->getEntityPersister($targetEntity);
+        $targetRegion    = $targetPersister->getCacheRegion();
+        $key             = new EntityCacheKey($targetEntity, $this->uow->getEntityIdentifier($element));
+
+        $targetRegion->evict($key);
+
+        if ($this->cacheLogger) {
+            $this->cacheLogger->entityCachePut($targetRegion->getName(), $key);
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Collection/CachedCollectionPersister.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\Persister\CachedPersister;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\PersistentCollection;
+
+/**
+ * Interface for second level cache collection persisters.
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+interface CachedCollectionPersister extends CachedPersister, CollectionPersister
+{
+    /**
+     * @return \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    public function getSourceEntityMetadata();
+
+    /**
+     * @return \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    public function getTargetEntityMetadata();
+
+    /**
+     * Loads a collection from cache
+     *
+     * @param \Doctrine\ORM\PersistentCollection     $collection
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey $key
+     *
+     * @return \Doctrine\ORM\PersistentCollection|null
+     */
+    public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key);
+
+    /**
+     * Stores a collection into cache
+     *
+     * @param \Doctrine\ORM\Cache\CollectionCacheKey        $key
+     * @param array|\Doctrine\Common\Collections\Collection $elements
+     *
+     * @return void
+     */
+    public function storeCollectionCache(CollectionCacheKey $key, $elements);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Collection/NonStrictReadWriteCachedCollectionPersister.php

@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\PersistentCollection;
+
+/**
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+class NonStrictReadWriteCachedCollectionPersister extends AbstractCollectionPersister
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionComplete()
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->storeCollectionCache($item['key'], $item['list']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $key) {
+                $this->region->evict($key);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionRolledBack()
+    {
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete(PersistentCollection $collection)
+    {
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
+
+        $this->persister->delete($collection);
+
+        $this->queuedCache['delete'][spl_object_hash($collection)] = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function update(PersistentCollection $collection)
+    {
+        $isInitialized = $collection->isInitialized();
+        $isDirty       = $collection->isDirty();
+
+        if ( ! $isInitialized && ! $isDirty) {
+            return;
+        }
+
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
+
+       // Invalidate non initialized collections OR ordered collection
+        if ($isDirty && ! $isInitialized || isset($this->association['orderBy'])) {
+            $this->persister->update($collection);
+
+            $this->queuedCache['delete'][spl_object_hash($collection)] = $key;
+
+            return;
+        }
+
+        $this->persister->update($collection);
+
+        $this->queuedCache['update'][spl_object_hash($collection)] = [
+            'key'   => $key,
+            'list'  => $collection
+        ];
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php

@@ -0,0 +1,44 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Cache\CacheException;
+use Doctrine\Common\Util\ClassUtils;
+
+/**
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+class ReadOnlyCachedCollectionPersister extends NonStrictReadWriteCachedCollectionPersister
+{
+     /**
+     * {@inheritdoc}
+     */
+    public function update(PersistentCollection $collection)
+    {
+        if ($collection->isDirty() && $collection->getSnapshot()) {
+            throw CacheException::updateReadOnlyCollection(ClassUtils::getClass($collection->getOwner()), $this->association['fieldName']);
+        }
+
+        parent::update($collection);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php

@@ -0,0 +1,134 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\ConcurrentRegion;
+use Doctrine\ORM\PersistentCollection;
+
+/**
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+class ReadWriteCachedCollectionPersister extends AbstractCollectionPersister
+{
+    /**
+     * @param \Doctrine\ORM\Persisters\Collection\CollectionPersister $persister   The collection persister that will be cached.
+     * @param \Doctrine\ORM\Cache\ConcurrentRegion                    $region      The collection region.
+     * @param \Doctrine\ORM\EntityManagerInterface                    $em          The entity manager.
+     * @param array                                                   $association The association mapping.
+     */
+    public function __construct(CollectionPersister $persister, ConcurrentRegion $region, EntityManagerInterface $em, array $association)
+    {
+        parent::__construct($persister, $region, $em, $association);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionComplete()
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionRolledBack()
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete(PersistentCollection $collection)
+    {
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
+        $lock    = $this->region->lock($key);
+
+        $this->persister->delete($collection);
+
+        if ($lock === null) {
+            return;
+        }
+
+        $this->queuedCache['delete'][spl_object_hash($collection)] = [
+            'key'   => $key,
+            'lock'  => $lock
+        ];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function update(PersistentCollection $collection)
+    {
+        $isInitialized = $collection->isInitialized();
+        $isDirty       = $collection->isDirty();
+
+        if ( ! $isInitialized && ! $isDirty) {
+            return;
+        }
+
+        $this->persister->update($collection);
+
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
+        $lock    = $this->region->lock($key);
+
+        if ($lock === null) {
+            return;
+        }
+
+        $this->queuedCache['update'][spl_object_hash($collection)] = [
+            'key'   => $key,
+            'lock'  => $lock
+        ];
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Entity/AbstractEntityPersister.php

@@ -0,0 +1,651 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Entity;
+
+use Doctrine\ORM\Cache;
+use Doctrine\ORM\Cache\Region;
+use Doctrine\ORM\Cache\EntityCacheKey;
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\TimestampCacheKey;
+use Doctrine\ORM\Cache\QueryCacheKey;
+use Doctrine\ORM\Cache\Persister\CachedPersister;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Persisters\Entity\EntityPersister;
+
+use Doctrine\Common\Util\ClassUtils;
+use Doctrine\Common\Collections\Criteria;
+
+/**
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+abstract class AbstractEntityPersister implements CachedEntityPersister
+{
+     /**
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    protected $uow;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadataFactory
+     */
+    protected $metadataFactory;
+
+    /**
+     * @var \Doctrine\ORM\Persisters\Entity\EntityPersister
+     */
+    protected $persister;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    protected $class;
+
+     /**
+     * @var array
+     */
+    protected $queuedCache = [];
+
+    /**
+     * @var \Doctrine\ORM\Cache\Region
+     */
+    protected $region;
+
+    /**
+     * @var \Doctrine\ORM\Cache\TimestampRegion
+     */
+    protected $timestampRegion;
+
+    /**
+     * @var \Doctrine\ORM\Cache\TimestampCacheKey
+     */
+    protected $timestampKey;
+
+    /**
+     * @var \Doctrine\ORM\Cache\EntityHydrator
+     */
+    protected $hydrator;
+
+    /**
+     * @var \Doctrine\ORM\Cache
+     */
+    protected $cache;
+
+    /**
+     * @var \Doctrine\ORM\Cache\Logging\CacheLogger
+     */
+    protected $cacheLogger;
+
+    /**
+     * @var string
+     */
+    protected $regionName;
+
+    /**
+     * Associations configured as FETCH_EAGER, as well as all inverse one-to-one associations.
+     *
+     * @var array|null
+     */
+    protected $joinedAssociations;
+
+    /**
+     * @param \Doctrine\ORM\Persisters\Entity\EntityPersister $persister The entity persister to cache.
+     * @param \Doctrine\ORM\Cache\Region                      $region    The entity cache region.
+     * @param \Doctrine\ORM\EntityManagerInterface            $em        The entity manager.
+     * @param \Doctrine\ORM\Mapping\ClassMetadata             $class     The entity metadata.
+     */
+    public function __construct(EntityPersister $persister, Region $region, EntityManagerInterface $em, ClassMetadata $class)
+    {
+        $configuration  = $em->getConfiguration();
+        $cacheConfig    = $configuration->getSecondLevelCacheConfiguration();
+        $cacheFactory   = $cacheConfig->getCacheFactory();
+
+        $this->class            = $class;
+        $this->region           = $region;
+        $this->persister        = $persister;
+        $this->cache            = $em->getCache();
+        $this->regionName       = $region->getName();
+        $this->uow              = $em->getUnitOfWork();
+        $this->metadataFactory  = $em->getMetadataFactory();
+        $this->cacheLogger      = $cacheConfig->getCacheLogger();
+        $this->timestampRegion  = $cacheFactory->getTimestampRegion();
+        $this->hydrator         = $cacheFactory->buildEntityHydrator($em, $class);
+        $this->timestampKey     = new TimestampCacheKey($this->class->rootEntityName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addInsert($entity)
+    {
+        $this->persister->addInsert($entity);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInserts()
+    {
+        return $this->persister->getInserts();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, array $orderBy = null)
+    {
+        return $this->persister->getSelectSQL($criteria, $assoc, $lockMode, $limit, $offset, $orderBy);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getCountSQL($criteria = [])
+    {
+        return $this->persister->getCountSQL($criteria);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInsertSQL()
+    {
+        return $this->persister->getInsertSQL();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getResultSetMapping()
+    {
+        return $this->persister->getResultSetMapping();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
+    {
+        return $this->persister->getSelectConditionStatementSQL($field, $value, $assoc, $comparison);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function exists($entity, Criteria $extraConditions = null)
+    {
+        if (null === $extraConditions) {
+            $key = new EntityCacheKey($this->class->rootEntityName, $this->class->getIdentifierValues($entity));
+
+            if ($this->region->contains($key)) {
+                return true;
+            }
+        }
+
+        return $this->persister->exists($entity, $extraConditions);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCacheRegion()
+    {
+        return $this->region;
+    }
+
+    /**
+     * @return \Doctrine\ORM\Cache\EntityHydrator
+     */
+    public function getEntityHydrator()
+    {
+        return $this->hydrator;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function storeEntityCache($entity, EntityCacheKey $key)
+    {
+        $class      = $this->class;
+        $className  = ClassUtils::getClass($entity);
+
+        if ($className !== $this->class->name) {
+            $class = $this->metadataFactory->getMetadataFor($className);
+        }
+
+        $entry  = $this->hydrator->buildCacheEntry($class, $key, $entity);
+        $cached = $this->region->put($key, $entry);
+
+        if ($this->cacheLogger && $cached) {
+            $this->cacheLogger->entityCachePut($this->regionName, $key);
+        }
+
+        return $cached;
+    }
+
+    /**
+     * @param object $entity
+     */
+    private function storeJoinedAssociations($entity)
+    {
+        if ($this->joinedAssociations === null) {
+            $associations = [];
+
+            foreach ($this->class->associationMappings as $name => $assoc) {
+                if (isset($assoc['cache']) &&
+                    ($assoc['type'] & ClassMetadata::TO_ONE) &&
+                    ($assoc['fetch'] === ClassMetadata::FETCH_EAGER || ! $assoc['isOwningSide'])) {
+
+                    $associations[] = $name;
+                }
+            }
+
+            $this->joinedAssociations = $associations;
+        }
+
+        foreach ($this->joinedAssociations as $name) {
+            $assoc       = $this->class->associationMappings[$name];
+            $assocEntity = $this->class->getFieldValue($entity, $name);
+
+            if ($assocEntity === null) {
+                continue;
+            }
+
+            $assocId        = $this->uow->getEntityIdentifier($assocEntity);
+            $assocMetadata  = $this->metadataFactory->getMetadataFor($assoc['targetEntity']);
+            $assocKey       = new EntityCacheKey($assocMetadata->rootEntityName, $assocId);
+            $assocPersister = $this->uow->getEntityPersister($assoc['targetEntity']);
+
+            $assocPersister->storeEntityCache($assocEntity, $assocKey);
+        }
+    }
+
+    /**
+     * Generates a string of currently query
+     *
+     * @param string            $query
+     * @param string[]|Criteria $criteria
+     * @param string[]          $orderBy
+     * @param int               $limit
+     * @param int               $offset
+     *
+     * @return string
+     */
+    protected function getHash($query, $criteria, array $orderBy = null, $limit = null, $offset = null)
+    {
+        [$params] = $criteria instanceof Criteria
+            ? $this->persister->expandCriteriaParameters($criteria)
+            : $this->persister->expandParameters($criteria);
+
+        return sha1($query . serialize($params) . serialize($orderBy) . $limit . $offset);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function expandParameters($criteria)
+    {
+        return $this->persister->expandParameters($criteria);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function expandCriteriaParameters(Criteria $criteria)
+    {
+        return $this->persister->expandCriteriaParameters($criteria);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getClassMetadata()
+    {
+        return $this->persister->getClassMetadata();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
+    {
+        return $this->persister->getManyToManyCollection($assoc, $sourceEntity, $offset, $limit);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
+    {
+        return $this->persister->getOneToManyCollection($assoc, $sourceEntity, $offset, $limit);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOwningTable($fieldName)
+    {
+        return $this->persister->getOwningTable($fieldName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function executeInserts()
+    {
+        $this->queuedCache['insert'] = $this->persister->getInserts();
+
+        return $this->persister->executeInserts();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, array $orderBy = null)
+    {
+        if ($entity !== null || $assoc !== null || ! empty($hints) || $lockMode !== null) {
+            return $this->persister->load($criteria, $entity, $assoc, $hints, $lockMode, $limit, $orderBy);
+        }
+
+        //handle only EntityRepository#findOneBy
+        $query      = $this->persister->getSelectSQL($criteria, null, null, $limit, null, $orderBy);
+        $hash       = $this->getHash($query, $criteria, null, null, null);
+        $rsm        = $this->getResultSetMapping();
+        $queryKey   = new QueryCacheKey($hash, 0, Cache::MODE_NORMAL, $this->timestampKey);
+        $queryCache = $this->cache->getQueryCache($this->regionName);
+        $result     = $queryCache->get($queryKey, $rsm);
+
+        if ($result !== null) {
+            if ($this->cacheLogger) {
+                $this->cacheLogger->queryCacheHit($this->regionName, $queryKey);
+            }
+
+            return $result[0];
+        }
+
+        if (($result = $this->persister->load($criteria, $entity, $assoc, $hints, $lockMode, $limit, $orderBy)) === null) {
+            return null;
+        }
+
+        $cached = $queryCache->put($queryKey, $rsm, [$result]);
+
+        if ($this->cacheLogger) {
+            if ($result) {
+                $this->cacheLogger->queryCacheMiss($this->regionName, $queryKey);
+            }
+
+            if ($cached) {
+                $this->cacheLogger->queryCachePut($this->regionName, $queryKey);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadAll(array $criteria = [], array $orderBy = null, $limit = null, $offset = null)
+    {
+        $query      = $this->persister->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
+        $hash       = $this->getHash($query, $criteria, null, null, null);
+        $rsm        = $this->getResultSetMapping();
+        $queryKey   = new QueryCacheKey($hash, 0, Cache::MODE_NORMAL, $this->timestampKey);
+        $queryCache = $this->cache->getQueryCache($this->regionName);
+        $result     = $queryCache->get($queryKey, $rsm);
+
+        if ($result !== null) {
+            if ($this->cacheLogger) {
+                $this->cacheLogger->queryCacheHit($this->regionName, $queryKey);
+            }
+
+            return $result;
+        }
+
+        $result = $this->persister->loadAll($criteria, $orderBy, $limit, $offset);
+        $cached = $queryCache->put($queryKey, $rsm, $result);
+
+        if ($this->cacheLogger) {
+            if ($result) {
+                $this->cacheLogger->queryCacheMiss($this->regionName, $queryKey);
+            }
+
+            if ($cached) {
+                $this->cacheLogger->queryCachePut($this->regionName, $queryKey);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadById(array $identifier, $entity = null)
+    {
+        $cacheKey   = new EntityCacheKey($this->class->rootEntityName, $identifier);
+        $cacheEntry = $this->region->get($cacheKey);
+        $class      = $this->class;
+
+        if ($cacheEntry !== null) {
+            if ($cacheEntry->class !== $this->class->name) {
+                $class = $this->metadataFactory->getMetadataFor($cacheEntry->class);
+            }
+
+            $cachedEntity = $this->hydrator->loadCacheEntry($class, $cacheKey, $cacheEntry, $entity);
+
+            if ($cachedEntity !== null) {
+                if ($this->cacheLogger) {
+                    $this->cacheLogger->entityCacheHit($this->regionName, $cacheKey);
+                }
+
+                return $cachedEntity;
+            }
+        }
+
+        $entity = $this->persister->loadById($identifier, $entity);
+
+        if ($entity === null) {
+            return null;
+        }
+
+        $class      = $this->class;
+        $className  = ClassUtils::getClass($entity);
+
+        if ($className !== $this->class->name) {
+            $class = $this->metadataFactory->getMetadataFor($className);
+        }
+
+        $cacheEntry = $this->hydrator->buildCacheEntry($class, $cacheKey, $entity);
+        $cached     = $this->region->put($cacheKey, $cacheEntry);
+
+        if ($cached && (null === $this->joinedAssociations || $this->joinedAssociations)) {
+            $this->storeJoinedAssociations($entity);
+        }
+
+        if ($this->cacheLogger) {
+            if ($cached) {
+                $this->cacheLogger->entityCachePut($this->regionName, $cacheKey);
+            }
+
+            $this->cacheLogger->entityCacheMiss($this->regionName, $cacheKey);
+        }
+
+        return $entity;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function count($criteria = [])
+    {
+        return $this->persister->count($criteria);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadCriteria(Criteria $criteria)
+    {
+        $orderBy     = $criteria->getOrderings();
+        $limit       = $criteria->getMaxResults();
+        $offset      = $criteria->getFirstResult();
+        $query       = $this->persister->getSelectSQL($criteria);
+        $hash        = $this->getHash($query, $criteria, $orderBy, $limit, $offset);
+        $rsm         = $this->getResultSetMapping();
+        $queryKey    = new QueryCacheKey($hash, 0, Cache::MODE_NORMAL, $this->timestampKey);
+        $queryCache  = $this->cache->getQueryCache($this->regionName);
+        $cacheResult = $queryCache->get($queryKey, $rsm);
+
+        if ($cacheResult !== null) {
+            if ($this->cacheLogger) {
+                $this->cacheLogger->queryCacheHit($this->regionName, $queryKey);
+            }
+
+            return $cacheResult;
+        }
+
+        $result = $this->persister->loadCriteria($criteria);
+        $cached = $queryCache->put($queryKey, $rsm, $result);
+
+        if ($this->cacheLogger) {
+            if ($result) {
+                $this->cacheLogger->queryCacheMiss($this->regionName, $queryKey);
+            }
+
+            if ($cached) {
+                $this->cacheLogger->queryCachePut($this->regionName, $queryKey);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
+    {
+        $persister = $this->uow->getCollectionPersister($assoc);
+        $hasCache  = ($persister instanceof CachedPersister);
+
+        if ( ! $hasCache) {
+            return $this->persister->loadManyToManyCollection($assoc, $sourceEntity, $collection);
+        }
+
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = $this->buildCollectionCacheKey($assoc, $ownerId);
+        $list    = $persister->loadCollectionCache($collection, $key);
+
+        if ($list !== null) {
+            if ($this->cacheLogger) {
+                $this->cacheLogger->collectionCacheHit($persister->getCacheRegion()->getName(), $key);
+            }
+
+            return $list;
+        }
+
+        $list = $this->persister->loadManyToManyCollection($assoc, $sourceEntity, $collection);
+
+        $persister->storeCollectionCache($key, $list);
+
+        if ($this->cacheLogger) {
+            $this->cacheLogger->collectionCacheMiss($persister->getCacheRegion()->getName(), $key);
+        }
+
+        return $list;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
+    {
+        $persister = $this->uow->getCollectionPersister($assoc);
+        $hasCache  = ($persister instanceof CachedPersister);
+
+        if ( ! $hasCache) {
+            return $this->persister->loadOneToManyCollection($assoc, $sourceEntity, $collection);
+        }
+
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = $this->buildCollectionCacheKey($assoc, $ownerId);
+        $list    = $persister->loadCollectionCache($collection, $key);
+
+        if ($list !== null) {
+            if ($this->cacheLogger) {
+                $this->cacheLogger->collectionCacheHit($persister->getCacheRegion()->getName(), $key);
+            }
+
+            return $list;
+        }
+
+        $list = $this->persister->loadOneToManyCollection($assoc, $sourceEntity, $collection);
+
+        $persister->storeCollectionCache($key, $list);
+
+        if ($this->cacheLogger) {
+            $this->cacheLogger->collectionCacheMiss($persister->getCacheRegion()->getName(), $key);
+        }
+
+        return $list;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
+    {
+        return $this->persister->loadOneToOneEntity($assoc, $sourceEntity, $identifier);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function lock(array $criteria, $lockMode)
+    {
+        $this->persister->lock($criteria, $lockMode);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function refresh(array $id, $entity, $lockMode = null)
+    {
+        $this->persister->refresh($id, $entity, $lockMode);
+    }
+
+    /**
+     * @param array $association
+     * @param array $ownerId
+     *
+     * @return CollectionCacheKey
+     */
+    protected function buildCollectionCacheKey(array $association, $ownerId)
+    {
+        /** @var ClassMetadata $metadata */
+        $metadata = $this->metadataFactory->getMetadataFor($association['sourceEntity']);
+
+        return new CollectionCacheKey($metadata->rootEntityName, $association['fieldName'], $ownerId);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Entity/CachedEntityPersister.php

@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Entity;
+
+use Doctrine\ORM\Cache\EntityCacheKey;
+use Doctrine\ORM\Cache\Persister\CachedPersister;
+use Doctrine\ORM\Persisters\Entity\EntityPersister;
+
+/**
+ * Interface for second level cache entity persisters.
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+interface CachedEntityPersister extends CachedPersister, EntityPersister
+{
+    /**
+     * @return \Doctrine\ORM\Cache\EntityHydrator
+     */
+    public function getEntityHydrator();
+
+    /**
+     * @param object                             $entity
+     * @param \Doctrine\ORM\Cache\EntityCacheKey $key
+     *
+     * @return boolean
+     */
+    public function storeEntityCache($entity, EntityCacheKey $key);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Entity/NonStrictReadWriteCachedEntityPersister.php

@@ -0,0 +1,123 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Entity;
+
+use Doctrine\ORM\Cache\EntityCacheKey;
+
+/**
+ * Specific non-strict read/write cached entity persister
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @since  2.5
+ */
+class NonStrictReadWriteCachedEntityPersister extends AbstractEntityPersister
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionComplete()
+    {
+        $isChanged = false;
+
+        if (isset($this->queuedCache['insert'])) {
+            foreach ($this->queuedCache['insert'] as $entity) {
+                $isChanged = $this->updateCache($entity, $isChanged);
+            }
+        }
+
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $entity) {
+                $isChanged = $this->updateCache($entity, $isChanged);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $key) {
+                $this->region->evict($key);
+
+                $isChanged = true;
+            }
+        }
+
+        if ($isChanged) {
+            $this->timestampRegion->update($this->timestampKey);
+        }
+
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionRolledBack()
+    {
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($entity)
+    {
+        $key     = new EntityCacheKey($this->class->rootEntityName, $this->uow->getEntityIdentifier($entity));
+        $deleted = $this->persister->delete($entity);
+
+        if ($deleted) {
+            $this->region->evict($key);
+        }
+
+        $this->queuedCache['delete'][] = $key;
+
+        return $deleted;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function update($entity)
+    {
+        $this->persister->update($entity);
+
+        $this->queuedCache['update'][] = $entity;
+    }
+
+    /**
+     * @param object $entity
+     * @param bool   $isChanged
+     *
+     * @return bool
+     */
+    private function updateCache($entity, $isChanged)
+    {
+        $class      = $this->metadataFactory->getMetadataFor(get_class($entity));
+        $key        = new EntityCacheKey($class->rootEntityName, $this->uow->getEntityIdentifier($entity));
+        $entry      = $this->hydrator->buildCacheEntry($class, $key, $entity);
+        $cached     = $this->region->put($key, $entry);
+        $isChanged  = $isChanged ?: $cached;
+
+        if ($this->cacheLogger && $cached) {
+            $this->cacheLogger->entityCachePut($this->regionName, $key);
+        }
+
+        return $isChanged;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Entity/ReadOnlyCachedEntityPersister.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Entity;
+
+use Doctrine\ORM\Cache\CacheException;
+use Doctrine\Common\Util\ClassUtils;
+
+/**
+ * Specific read-only region entity persister
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since 2.5
+ */
+class ReadOnlyCachedEntityPersister extends NonStrictReadWriteCachedEntityPersister
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function update($entity)
+    {
+        throw CacheException::updateReadOnlyEntity(ClassUtils::getClass($entity));
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Entity/ReadWriteCachedEntityPersister.php

@@ -0,0 +1,143 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Persister\Entity;
+
+use Doctrine\ORM\Persisters\Entity\EntityPersister;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Cache\ConcurrentRegion;
+use Doctrine\ORM\Cache\EntityCacheKey;
+
+/**
+ * Specific read-write entity persister
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @since 2.5
+ */
+class ReadWriteCachedEntityPersister extends AbstractEntityPersister
+{
+    /**
+     * @param \Doctrine\ORM\Persisters\Entity\EntityPersister $persister The entity persister to cache.
+     * @param \Doctrine\ORM\Cache\ConcurrentRegion            $region    The entity cache region.
+     * @param \Doctrine\ORM\EntityManagerInterface            $em        The entity manager.
+     * @param \Doctrine\ORM\Mapping\ClassMetadata             $class     The entity metadata.
+     */
+    public function __construct(EntityPersister $persister, ConcurrentRegion $region, EntityManagerInterface $em, ClassMetadata $class)
+    {
+        parent::__construct($persister, $region, $em, $class);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionComplete()
+    {
+        $isChanged = true;
+
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->region->evict($item['key']);
+
+                $isChanged = true;
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $item) {
+                $this->region->evict($item['key']);
+
+                $isChanged = true;
+            }
+        }
+
+        if ($isChanged) {
+            $this->timestampRegion->update($this->timestampKey);
+        }
+
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function afterTransactionRolledBack()
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($entity)
+    {
+        $key     = new EntityCacheKey($this->class->rootEntityName, $this->uow->getEntityIdentifier($entity));
+        $lock    = $this->region->lock($key);
+        $deleted = $this->persister->delete($entity);
+
+        if ($deleted) {
+            $this->region->evict($key);
+        }
+
+        if ($lock === null) {
+            return $deleted;
+        }
+
+        $this->queuedCache['delete'][] = [
+            'lock'   => $lock,
+            'key'    => $key
+        ];
+
+        return $deleted;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function update($entity)
+    {
+        $key  = new EntityCacheKey($this->class->rootEntityName, $this->uow->getEntityIdentifier($entity));
+        $lock = $this->region->lock($key);
+
+        $this->persister->update($entity);
+
+        if ($lock === null) {
+            return;
+        }
+
+        $this->queuedCache['update'][] = [
+            'lock'   => $lock,
+            'key'    => $key
+        ];
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/QueryCache.php

@@ -0,0 +1,62 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Query\ResultSetMapping;
+
+/**
+ * Defines the contract for caches capable of storing query results.
+ * These caches should only concern themselves with storing the matching result ids.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface QueryCache
+{
+    /**
+     * @return boolean
+     */
+    public function clear();
+
+    /**
+     * @param \Doctrine\ORM\Cache\QueryCacheKey    $key
+     * @param \Doctrine\ORM\Query\ResultSetMapping $rsm
+     * @param mixed                                $result
+     * @param array                                $hints
+     *
+     * @return boolean
+     */
+    public function put(QueryCacheKey $key, ResultSetMapping $rsm, $result, array $hints = []);
+
+    /**
+     * @param \Doctrine\ORM\Cache\QueryCacheKey     $key
+     * @param \Doctrine\ORM\Query\ResultSetMapping  $rsm
+     * @param array                                 $hints
+     *
+     * @return array|null
+     */
+    public function get(QueryCacheKey $key, ResultSetMapping $rsm, array $hints = []);
+
+    /**
+     * @return \Doctrine\ORM\Cache\Region
+     */
+    public function getRegion();
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/QueryCacheEntry.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Query cache entry
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class QueryCacheEntry implements CacheEntry
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var array List of entity identifiers
+     */
+    public $result;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var float Time creation of this cache entry
+     */
+    public $time;
+
+    /**
+     * @param array $result
+     * @param float $time
+     */
+    public function __construct($result, $time = null)
+    {
+        $this->result = $result;
+        $this->time   = $time ?: microtime(true);
+    }
+
+    /**
+     * @param array $values
+     *
+     * @return QueryCacheEntry
+     */
+    public static function __set_state(array $values)
+    {
+        return new self($values['result'], $values['time']);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/QueryCacheKey.php

@@ -0,0 +1,71 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+use Doctrine\ORM\Cache;
+
+/**
+ * A cache key that identifies a particular query.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class QueryCacheKey extends CacheKey
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var integer Cache key lifetime
+     */
+    public $lifetime;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var integer Cache mode (Doctrine\ORM\Cache::MODE_*)
+     */
+    public $cacheMode;
+
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var TimestampCacheKey|null
+     */
+    public $timestampKey;
+
+    /**
+     * @param string $hash Result cache id
+     * @param integer $lifetime Query lifetime
+     * @param int $cacheMode Query cache mode
+     * @param TimestampCacheKey|null $timestampKey
+     */
+    public function __construct(
+        $hash,
+        $lifetime = 0,
+        $cacheMode = Cache::MODE_NORMAL,
+        TimestampCacheKey $timestampKey = null
+    ) {
+        $this->hash         = $hash;
+        $this->lifetime     = $lifetime;
+        $this->cacheMode    = $cacheMode;
+        $this->timestampKey = $timestampKey;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/QueryCacheValidator.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Cache query validator interface.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface QueryCacheValidator
+{
+    /**
+     * Checks if the query entry is valid
+     *
+     * @param \Doctrine\ORM\Cache\QueryCacheKey   $key
+     * @param \Doctrine\ORM\Cache\QueryCacheEntry $entry
+     *
+     * @return boolean
+     */
+    public function isValid(QueryCacheKey $key, QueryCacheEntry $entry);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Region.php

@@ -0,0 +1,84 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines a contract for accessing a particular named region.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface Region extends MultiGetRegion
+{
+    /**
+     * Retrieve the name of this region.
+     *
+     * @return string The region name
+     */
+    public function getName();
+
+    /**
+     * Determine whether this region contains data for the given key.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey $key The cache key
+     *
+     * @return boolean TRUE if the underlying cache contains corresponding data; FALSE otherwise.
+     */
+    public function contains(CacheKey $key);
+
+    /**
+     * Get an item from the cache.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey $key The key of the item to be retrieved.
+     *
+     * @return \Doctrine\ORM\Cache\CacheEntry|null The cached entry or NULL
+     *
+     * @throws \Doctrine\ORM\Cache\CacheException Indicates a problem accessing the item or region.
+     */
+    public function get(CacheKey $key);
+
+    /**
+     * Put an item into the cache.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey   $key   The key under which to cache the item.
+     * @param \Doctrine\ORM\Cache\CacheEntry $entry The entry to cache.
+     * @param \Doctrine\ORM\Cache\Lock       $lock  The lock previously obtained.
+     *
+     * @throws \Doctrine\ORM\Cache\CacheException Indicates a problem accessing the region.
+     */
+    public function put(CacheKey $key, CacheEntry $entry, Lock $lock = null);
+
+    /**
+     * Remove an item from the cache.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey $key The key under which to cache the item.
+     *
+     * @throws \Doctrine\ORM\Cache\CacheException Indicates a problem accessing the region.
+     */
+    public function evict(CacheKey $key);
+
+    /**
+     * Remove all contents of this particular cache region.
+     *
+     * @throws \Doctrine\ORM\Cache\CacheException Indicates problem accessing the region.
+     */
+    public function evictAll();
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Region/DefaultMultiGetRegion.php

@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Region;
+
+use Doctrine\Common\Cache\MultiGetCache;
+use Doctrine\ORM\Cache\CacheEntry;
+use Doctrine\ORM\Cache\CollectionCacheEntry;
+
+/**
+ * A cache region that enables the retrieval of multiple elements with one call
+ *
+ * @since   2.5
+ * @author  Asmir Mustafic <goetas@gmail.com>
+ */
+class DefaultMultiGetRegion extends DefaultRegion
+{
+    /**
+     * Note that the multiple type is due to doctrine/cache not integrating the MultiGetCache interface
+     * in its signature due to BC in 1.x
+     *
+     * @var MultiGetCache|\Doctrine\Common\Cache\Cache
+     */
+    protected $cache;
+
+    /**
+     * {@inheritDoc}
+     *
+     * @param MultiGetCache $cache
+     */
+    public function __construct($name, MultiGetCache $cache, $lifetime = 0)
+    {
+        /* @var $cache \Doctrine\Common\Cache\Cache */
+        parent::__construct($name, $cache, $lifetime);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple(CollectionCacheEntry $collection)
+    {
+        $keysToRetrieve = [];
+
+        foreach ($collection->identifiers as $index => $key) {
+            $keysToRetrieve[$index] = $this->getCacheEntryKey($key);
+        }
+
+        $items = $this->cache->fetchMultiple($keysToRetrieve);
+        if (count($items) !== count($keysToRetrieve)) {
+            return null;
+        }
+
+        $returnableItems = [];
+
+        foreach ($keysToRetrieve as $index => $key) {
+            if (! $items[$key] instanceof CacheEntry) {
+                return null;
+            }
+
+            $returnableItems[$index] = $items[$key];
+        }
+
+        return $returnableItems;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Region/DefaultRegion.php

@@ -0,0 +1,166 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Region;
+
+use Doctrine\Common\Cache\Cache as CacheAdapter;
+use Doctrine\Common\Cache\ClearableCache;
+use Doctrine\ORM\Cache\CacheEntry;
+use Doctrine\ORM\Cache\CacheKey;
+use Doctrine\ORM\Cache\CollectionCacheEntry;
+use Doctrine\ORM\Cache\Lock;
+use Doctrine\ORM\Cache\Region;
+
+/**
+ * The simplest cache region compatible with all doctrine-cache drivers.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultRegion implements Region
+{
+    const REGION_KEY_SEPARATOR = '_';
+
+    /**
+     * @var CacheAdapter
+     */
+    protected $cache;
+
+    /**
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * @var integer
+     */
+    protected $lifetime = 0;
+
+    /**
+     * @param string       $name
+     * @param CacheAdapter $cache
+     * @param integer      $lifetime
+     */
+    public function __construct($name, CacheAdapter $cache, $lifetime = 0)
+    {
+        $this->cache    = $cache;
+        $this->name     = (string) $name;
+        $this->lifetime = (integer) $lifetime;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return \Doctrine\Common\Cache\CacheProvider
+     */
+    public function getCache()
+    {
+        return $this->cache;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function contains(CacheKey $key)
+    {
+        return $this->cache->contains($this->getCacheEntryKey($key));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get(CacheKey $key)
+    {
+        $entry = $this->cache->fetch($this->getCacheEntryKey($key));
+
+        if (! $entry instanceof CacheEntry) {
+            return null;
+        }
+
+        return $entry;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple(CollectionCacheEntry $collection)
+    {
+        $result = [];
+
+        foreach ($collection->identifiers as $key) {
+            $entryKey   = $this->getCacheEntryKey($key);
+            $entryValue = $this->cache->fetch($entryKey);
+
+            if (! $entryValue instanceof CacheEntry) {
+                return null;
+            }
+
+            $result[] = $entryValue;
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param CacheKey $key
+     * @return string
+     */
+    protected function getCacheEntryKey(CacheKey $key)
+    {
+        return $this->name . self::REGION_KEY_SEPARATOR . $key->hash;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function put(CacheKey $key, CacheEntry $entry, Lock $lock = null)
+    {
+        return $this->cache->save($this->getCacheEntryKey($key), $entry, $this->lifetime);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evict(CacheKey $key)
+    {
+        return $this->cache->delete($this->getCacheEntryKey($key));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictAll()
+    {
+        if (! $this->cache instanceof ClearableCache) {
+            throw new \BadMethodCallException(sprintf(
+                'Clearing all cache entries is not supported by the supplied cache adapter of type %s',
+                get_class($this->cache)
+            ));
+        }
+
+        return $this->cache->deleteAll();
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Region/FileLockRegion.php

@@ -0,0 +1,267 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Region;
+
+use Doctrine\ORM\Cache\CollectionCacheEntry;
+use Doctrine\ORM\Cache\Lock;
+use Doctrine\ORM\Cache\Region;
+use Doctrine\ORM\Cache\CacheKey;
+use Doctrine\ORM\Cache\CacheEntry;
+use Doctrine\ORM\Cache\ConcurrentRegion;
+
+/**
+ * Very naive concurrent region, based on file locks.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silvagmail.com>
+ */
+class FileLockRegion implements ConcurrentRegion
+{
+    const LOCK_EXTENSION = 'lock';
+
+    /**
+     * var \Doctrine\ORM\Cache\Region
+     */
+    private $region;
+
+    /**
+     * @var string
+     */
+    private $directory;
+
+    /**
+     * var integer
+     */
+    private $lockLifetime;
+
+    /**
+     * @param \Doctrine\ORM\Cache\Region $region
+     * @param string                     $directory
+     * @param string                     $lockLifetime
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(Region $region, $directory, $lockLifetime)
+    {
+        if ( ! is_dir($directory) && ! @mkdir($directory, 0775, true)) {
+            throw new \InvalidArgumentException(sprintf('The directory "%s" does not exist and could not be created.', $directory));
+        }
+
+        if ( ! is_writable($directory)) {
+            throw new \InvalidArgumentException(sprintf('The directory "%s" is not writable.', $directory));
+        }
+
+        $this->region       = $region;
+        $this->directory    = $directory;
+        $this->lockLifetime = $lockLifetime;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\CacheKey $key
+     * @param \Doctrine\ORM\Cache\Lock     $lock
+     *
+     * @return boolean
+     */
+    private function isLocked(CacheKey $key, Lock $lock = null)
+    {
+        $filename = $this->getLockFileName($key);
+
+        if ( ! is_file($filename)) {
+            return false;
+        }
+
+        $time     = $this->getLockTime($filename);
+        $content  = $this->getLockContent($filename);
+
+        if ( ! $content || ! $time) {
+            @unlink($filename);
+
+            return false;
+        }
+
+        if ($lock && $content === $lock->value) {
+            return false;
+        }
+
+        // outdated lock
+        if (($time + $this->lockLifetime) <= time()) {
+            @unlink($filename);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param \Doctrine\ORM\Cache\CacheKey $key
+     *
+     * @return string
+     */
+    private function getLockFileName(CacheKey $key)
+    {
+        return $this->directory . DIRECTORY_SEPARATOR . $key->hash . '.' . self::LOCK_EXTENSION;
+    }
+
+    /**
+     * @param string $filename
+     *
+     * @return string
+     */
+    private function getLockContent($filename)
+    {
+        return @file_get_contents($filename);
+    }
+
+    /**
+     * @param string $filename
+     *
+     * @return integer
+     */
+    private function getLockTime($filename)
+    {
+        return @fileatime($filename);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return $this->region->getName();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function contains(CacheKey $key)
+    {
+        if ($this->isLocked($key)) {
+            return false;
+        }
+
+        return $this->region->contains($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get(CacheKey $key)
+    {
+        if ($this->isLocked($key)) {
+            return null;
+        }
+
+        return $this->region->get($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple(CollectionCacheEntry $collection)
+    {
+        if (array_filter(array_map([$this, 'isLocked'], $collection->identifiers))) {
+            return null;
+        }
+
+        return $this->region->getMultiple($collection);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function put(CacheKey $key, CacheEntry $entry, Lock $lock = null)
+    {
+        if ($this->isLocked($key, $lock)) {
+            return false;
+        }
+
+        return $this->region->put($key, $entry);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evict(CacheKey $key)
+    {
+        if ($this->isLocked($key)) {
+            @unlink($this->getLockFileName($key));
+        }
+
+        return $this->region->evict($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function evictAll()
+    {
+        // The check below is necessary because on some platforms glob returns false
+        // when nothing matched (even though no errors occurred)
+        $filenames = glob(sprintf("%s/*.%s" , $this->directory, self::LOCK_EXTENSION));
+
+        if ($filenames) {
+            foreach ($filenames as $filename) {
+                @unlink($filename);
+            }
+        }
+
+        return $this->region->evictAll();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function lock(CacheKey $key)
+    {
+        if ($this->isLocked($key)) {
+            return null;
+        }
+
+        $lock     = Lock::createLockRead();
+        $filename = $this->getLockFileName($key);
+
+        if ( ! @file_put_contents($filename, $lock->value, LOCK_EX)) {
+            return null;
+        }
+        chmod($filename, 0664);
+
+        return $lock;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    public function unlock(CacheKey $key, Lock $lock)
+    {
+        if ($this->isLocked($key, $lock)) {
+            return false;
+        }
+
+        if ( ! @unlink($this->getLockFileName($key))) {
+            return false;
+        }
+
+        return true;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Region/UpdateTimestampCache.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache\Region;
+
+use Doctrine\ORM\Cache\TimestampCacheEntry;
+use Doctrine\ORM\Cache\TimestampRegion;
+use Doctrine\ORM\Cache\CacheKey;
+
+/**
+ * Tracks the timestamps of the most recent updates to particular keys.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class UpdateTimestampCache extends DefaultRegion implements TimestampRegion
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function update(CacheKey $key)
+    {
+        $this->put($key, new TimestampCacheEntry);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/RegionsConfiguration.php

@@ -0,0 +1,134 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Cache regions configuration
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class RegionsConfiguration
+{
+    /**
+     * @var array
+     */
+    private $lifetimes = [];
+
+    /**
+     * @var array
+     */
+    private $lockLifetimes = [];
+
+    /**
+     * @var integer
+     */
+    private $defaultLifetime;
+
+    /**
+     * @var integer
+     */
+    private $defaultLockLifetime;
+
+    /**
+     * @param integer $defaultLifetime
+     * @param integer $defaultLockLifetime
+     */
+    public function __construct($defaultLifetime = 3600, $defaultLockLifetime = 60)
+    {
+        $this->defaultLifetime      = (integer) $defaultLifetime;
+        $this->defaultLockLifetime  = (integer) $defaultLockLifetime;
+    }
+
+    /**
+     * @return integer
+     */
+    public function getDefaultLifetime()
+    {
+        return $this->defaultLifetime;
+    }
+
+    /**
+     * @param integer $defaultLifetime
+     */
+    public function setDefaultLifetime($defaultLifetime)
+    {
+        $this->defaultLifetime = (integer) $defaultLifetime;
+    }
+
+    /**
+     * @return integer
+     */
+    public function getDefaultLockLifetime()
+    {
+        return $this->defaultLockLifetime;
+    }
+
+    /**
+     * @param integer $defaultLockLifetime
+     */
+    public function setDefaultLockLifetime($defaultLockLifetime)
+    {
+        $this->defaultLockLifetime = (integer) $defaultLockLifetime;
+    }
+
+    /**
+     * @param string $regionName
+     *
+     * @return integer
+     */
+    public function getLifetime($regionName)
+    {
+        return isset($this->lifetimes[$regionName])
+            ? $this->lifetimes[$regionName]
+            : $this->defaultLifetime;
+    }
+
+    /**
+     * @param string  $name
+     * @param integer $lifetime
+     */
+    public function setLifetime($name, $lifetime)
+    {
+        $this->lifetimes[$name] = (integer) $lifetime;
+    }
+
+    /**
+     * @param string $regionName
+     *
+     * @return integer
+     */
+    public function getLockLifetime($regionName)
+    {
+        return isset($this->lockLifetimes[$regionName])
+            ? $this->lockLifetimes[$regionName]
+            : $this->defaultLockLifetime;
+    }
+
+    /**
+     * @param string  $name
+     * @param integer $lifetime
+     */
+    public function setLockLifetime($name, $lifetime)
+    {
+        $this->lockLifetimes[$name] = (integer) $lifetime;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/TimestampCacheEntry.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Timestamp cache entry
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class TimestampCacheEntry implements CacheEntry
+{
+    /**
+     * READ-ONLY: Public only for performance reasons, it should be considered immutable.
+     *
+     * @var float
+     */
+    public $time;
+
+    /**
+     * @param float $time
+     */
+    public function __construct($time = null)
+    {
+        $this->time = $time ? (float) $time : microtime(true);
+    }
+
+    /**
+     * Creates a new TimestampCacheEntry
+     *
+     * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
+     *
+     * @param array $values array containing property values
+     *
+     * @return TimestampCacheEntry
+     */
+    public static function __set_state(array $values)
+    {
+        return new self($values['time']);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/TimestampCacheKey.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * A key that identifies a timestamped space.
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class TimestampCacheKey extends CacheKey
+{
+    /**
+     * @param string $space Result cache id
+     */
+    public function __construct($space)
+    {
+        $this->hash = (string) $space;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/TimestampQueryCacheValidator.php

@@ -0,0 +1,74 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class TimestampQueryCacheValidator implements QueryCacheValidator
+{
+    /**
+     * @var TimestampRegion
+     */
+    private $timestampRegion;
+
+    /**
+     * @param TimestampRegion $timestampRegion
+     */
+    public function __construct(TimestampRegion $timestampRegion)
+    {
+        $this->timestampRegion = $timestampRegion;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isValid(QueryCacheKey $key, QueryCacheEntry $entry)
+    {
+        if ($this->regionUpdated($key, $entry)) {
+            return false;
+        }
+
+        if ($key->lifetime == 0) {
+            return true;
+        }
+
+        return ($entry->time + $key->lifetime) > microtime(true);
+    }
+
+    /**
+     * @param QueryCacheKey   $key
+     * @param QueryCacheEntry $entry
+     *
+     * @return bool
+     */
+    private function regionUpdated(QueryCacheKey $key, QueryCacheEntry $entry)
+    {
+        if ($key->timestampKey === null) {
+            return false;
+        }
+
+        $timestamp = $this->timestampRegion->get($key->timestampKey);
+
+        return $timestamp && $timestamp->time > $entry->time;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Cache/TimestampRegion.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Cache;
+
+/**
+ * Defines the contract for a cache region which will specifically be used to store entity "update timestamps".
+ *
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface TimestampRegion extends Region
+{
+    /**
+     * Update an specific key into the cache region.
+     *
+     * @param \Doctrine\ORM\Cache\CacheKey $key The key of the item to update the timestamp.
+     *
+     * @throws \Doctrine\ORM\Cache\LockException Indicates a problem accessing the region.
+     */
+    public function update(CacheKey $key);
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Configuration.php

@@ -0,0 +1,941 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\AnnotationRegistry;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\SimpleAnnotationReader;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Cache\Cache as CacheDriver;
+use Doctrine\Common\Proxy\AbstractProxyFactory;
+use Doctrine\ORM\Cache\CacheConfiguration;
+use Doctrine\ORM\Mapping\ClassMetadataFactory;
+use Doctrine\ORM\Mapping\DefaultEntityListenerResolver;
+use Doctrine\ORM\Mapping\DefaultNamingStrategy;
+use Doctrine\ORM\Mapping\DefaultQuoteStrategy;
+use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
+use Doctrine\ORM\Mapping\EntityListenerResolver;
+use Doctrine\ORM\Mapping\NamingStrategy;
+use Doctrine\ORM\Mapping\QuoteStrategy;
+use Doctrine\ORM\Repository\DefaultRepositoryFactory;
+use Doctrine\ORM\Repository\RepositoryFactory;
+use Doctrine\Persistence\Mapping\Driver\MappingDriver;
+use Doctrine\Persistence\ObjectRepository;
+use function interface_exists;
+
+/**
+ * Configuration container for all configuration options of Doctrine.
+ * It combines all configuration options from DBAL & ORM.
+ *
+ * Internal note: When adding a new configuration option just write a getter/setter pair.
+ *
+ * @since 2.0
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author  Jonathan Wage <jonwage@gmail.com>
+ * @author  Roman Borschel <roman@code-factory.org>
+ */
+class Configuration extends \Doctrine\DBAL\Configuration
+{
+    /**
+     * Sets the directory where Doctrine generates any necessary proxy class files.
+     *
+     * @param string $dir
+     *
+     * @return void
+     */
+    public function setProxyDir($dir)
+    {
+        $this->_attributes['proxyDir'] = $dir;
+    }
+
+    /**
+     * Gets the directory where Doctrine generates any necessary proxy class files.
+     *
+     * @return string|null
+     *
+     * @deprecated 2.7 We're switch to `ocramius/proxy-manager` and this method isn't applicable any longer
+     * @see https://github.com/Ocramius/ProxyManager
+     */
+    public function getProxyDir()
+    {
+        return isset($this->_attributes['proxyDir'])
+            ? $this->_attributes['proxyDir']
+            : null;
+    }
+
+    /**
+     * Gets the strategy for automatically generating proxy classes.
+     *
+     * @return int Possible values are constants of Doctrine\Common\Proxy\AbstractProxyFactory.
+     *
+     * @deprecated 2.7 We're switch to `ocramius/proxy-manager` and this method isn't applicable any longer
+     * @see https://github.com/Ocramius/ProxyManager
+     */
+    public function getAutoGenerateProxyClasses()
+    {
+        return isset($this->_attributes['autoGenerateProxyClasses'])
+            ? $this->_attributes['autoGenerateProxyClasses']
+            : AbstractProxyFactory::AUTOGENERATE_ALWAYS;
+    }
+
+    /**
+     * Sets the strategy for automatically generating proxy classes.
+     *
+     * @param boolean|int $autoGenerate Possible values are constants of Doctrine\Common\Proxy\AbstractProxyFactory.
+     *                                  True is converted to AUTOGENERATE_ALWAYS, false to AUTOGENERATE_NEVER.
+     *
+     * @return void
+     */
+    public function setAutoGenerateProxyClasses($autoGenerate)
+    {
+        $this->_attributes['autoGenerateProxyClasses'] = (int) $autoGenerate;
+    }
+
+    /**
+     * Gets the namespace where proxy classes reside.
+     *
+     * @return string|null
+     *
+     * @deprecated 2.7 We're switch to `ocramius/proxy-manager` and this method isn't applicable any longer
+     * @see https://github.com/Ocramius/ProxyManager
+     */
+    public function getProxyNamespace()
+    {
+        return isset($this->_attributes['proxyNamespace'])
+            ? $this->_attributes['proxyNamespace']
+            : null;
+    }
+
+    /**
+     * Sets the namespace where proxy classes reside.
+     *
+     * @param string $ns
+     *
+     * @return void
+     */
+    public function setProxyNamespace($ns)
+    {
+        $this->_attributes['proxyNamespace'] = $ns;
+    }
+
+    /**
+     * Sets the cache driver implementation that is used for metadata caching.
+     *
+     * @param MappingDriver $driverImpl
+     *
+     * @return void
+     *
+     * @todo Force parameter to be a Closure to ensure lazy evaluation
+     *       (as soon as a metadata cache is in effect, the driver never needs to initialize).
+     */
+    public function setMetadataDriverImpl(MappingDriver $driverImpl)
+    {
+        $this->_attributes['metadataDriverImpl'] = $driverImpl;
+    }
+
+    /**
+     * Adds a new default annotation driver with a correctly configured annotation reader. If $useSimpleAnnotationReader
+     * is true, the notation `@Entity` will work, otherwise, the notation `@ORM\Entity` will be supported.
+     *
+     * @param array $paths
+     * @param bool  $useSimpleAnnotationReader
+     *
+     * @return AnnotationDriver
+     */
+    public function newDefaultAnnotationDriver($paths = [], $useSimpleAnnotationReader = true)
+    {
+        AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php');
+
+        if ($useSimpleAnnotationReader) {
+            // Register the ORM Annotations in the AnnotationRegistry
+            $reader = new SimpleAnnotationReader();
+            $reader->addNamespace('Doctrine\ORM\Mapping');
+            $cachedReader = new CachedReader($reader, new ArrayCache());
+
+            return new AnnotationDriver($cachedReader, (array) $paths);
+        }
+
+        return new AnnotationDriver(
+            new CachedReader(new AnnotationReader(), new ArrayCache()),
+            (array) $paths
+        );
+    }
+
+    /**
+     * Adds a namespace under a certain alias.
+     *
+     * @param string $alias
+     * @param string $namespace
+     *
+     * @return void
+     */
+    public function addEntityNamespace($alias, $namespace)
+    {
+        $this->_attributes['entityNamespaces'][$alias] = $namespace;
+    }
+
+    /**
+     * Resolves a registered namespace alias to the full namespace.
+     *
+     * @param string $entityNamespaceAlias
+     *
+     * @return string
+     *
+     * @throws ORMException
+     */
+    public function getEntityNamespace($entityNamespaceAlias)
+    {
+        if ( ! isset($this->_attributes['entityNamespaces'][$entityNamespaceAlias])) {
+            throw ORMException::unknownEntityNamespace($entityNamespaceAlias);
+        }
+
+        return trim($this->_attributes['entityNamespaces'][$entityNamespaceAlias], '\\');
+    }
+
+    /**
+     * Sets the entity alias map.
+     *
+     * @param array $entityNamespaces
+     *
+     * @return void
+     */
+    public function setEntityNamespaces(array $entityNamespaces)
+    {
+        $this->_attributes['entityNamespaces'] = $entityNamespaces;
+    }
+
+    /**
+     * Retrieves the list of registered entity namespace aliases.
+     *
+     * @return array
+     */
+    public function getEntityNamespaces()
+    {
+        return $this->_attributes['entityNamespaces'];
+    }
+
+    /**
+     * Gets the cache driver implementation that is used for the mapping metadata.
+     *
+     * @return MappingDriver|null
+     *
+     * @throws ORMException
+     */
+    public function getMetadataDriverImpl()
+    {
+        return isset($this->_attributes['metadataDriverImpl'])
+            ? $this->_attributes['metadataDriverImpl']
+            : null;
+    }
+
+    /**
+     * Gets the cache driver implementation that is used for the query cache (SQL cache).
+     *
+     * @return \Doctrine\Common\Cache\Cache|null
+     */
+    public function getQueryCacheImpl()
+    {
+        return isset($this->_attributes['queryCacheImpl'])
+            ? $this->_attributes['queryCacheImpl']
+            : null;
+    }
+
+    /**
+     * Sets the cache driver implementation that is used for the query cache (SQL cache).
+     *
+     * @param \Doctrine\Common\Cache\Cache $cacheImpl
+     *
+     * @return void
+     */
+    public function setQueryCacheImpl(CacheDriver $cacheImpl)
+    {
+        $this->_attributes['queryCacheImpl'] = $cacheImpl;
+    }
+
+    /**
+     * Gets the cache driver implementation that is used for the hydration cache (SQL cache).
+     *
+     * @return \Doctrine\Common\Cache\Cache|null
+     */
+    public function getHydrationCacheImpl()
+    {
+        return isset($this->_attributes['hydrationCacheImpl'])
+            ? $this->_attributes['hydrationCacheImpl']
+            : null;
+    }
+
+    /**
+     * Sets the cache driver implementation that is used for the hydration cache (SQL cache).
+     *
+     * @param \Doctrine\Common\Cache\Cache $cacheImpl
+     *
+     * @return void
+     */
+    public function setHydrationCacheImpl(CacheDriver $cacheImpl)
+    {
+        $this->_attributes['hydrationCacheImpl'] = $cacheImpl;
+    }
+
+    /**
+     * Gets the cache driver implementation that is used for metadata caching.
+     *
+     * @return \Doctrine\Common\Cache\Cache|null
+     */
+    public function getMetadataCacheImpl()
+    {
+        return isset($this->_attributes['metadataCacheImpl'])
+            ? $this->_attributes['metadataCacheImpl']
+            : null;
+    }
+
+    /**
+     * Sets the cache driver implementation that is used for metadata caching.
+     *
+     * @param \Doctrine\Common\Cache\Cache $cacheImpl
+     *
+     * @return void
+     */
+    public function setMetadataCacheImpl(CacheDriver $cacheImpl)
+    {
+        $this->_attributes['metadataCacheImpl'] = $cacheImpl;
+    }
+
+    /**
+     * Adds a named DQL query to the configuration.
+     *
+     * @param string $name The name of the query.
+     * @param string $dql  The DQL query string.
+     *
+     * @return void
+     */
+    public function addNamedQuery($name, $dql)
+    {
+        $this->_attributes['namedQueries'][$name] = $dql;
+    }
+
+    /**
+     * Gets a previously registered named DQL query.
+     *
+     * @param string $name The name of the query.
+     *
+     * @return string The DQL query.
+     *
+     * @throws ORMException
+     */
+    public function getNamedQuery($name)
+    {
+        if ( ! isset($this->_attributes['namedQueries'][$name])) {
+            throw ORMException::namedQueryNotFound($name);
+        }
+
+        return $this->_attributes['namedQueries'][$name];
+    }
+
+    /**
+     * Adds a named native query to the configuration.
+     *
+     * @param string                 $name The name of the query.
+     * @param string                 $sql  The native SQL query string.
+     * @param Query\ResultSetMapping $rsm  The ResultSetMapping used for the results of the SQL query.
+     *
+     * @return void
+     */
+    public function addNamedNativeQuery($name, $sql, Query\ResultSetMapping $rsm)
+    {
+        $this->_attributes['namedNativeQueries'][$name] = [$sql, $rsm];
+    }
+
+    /**
+     * Gets the components of a previously registered named native query.
+     *
+     * @param string $name The name of the query.
+     *
+     * @return array A tuple with the first element being the SQL string and the second
+     *               element being the ResultSetMapping.
+     *
+     * @throws ORMException
+     */
+    public function getNamedNativeQuery($name)
+    {
+        if ( ! isset($this->_attributes['namedNativeQueries'][$name])) {
+            throw ORMException::namedNativeQueryNotFound($name);
+        }
+
+        return $this->_attributes['namedNativeQueries'][$name];
+    }
+
+    /**
+     * Ensures that this Configuration instance contains settings that are
+     * suitable for a production environment.
+     *
+     * @return void
+     *
+     * @throws ORMException If a configuration setting has a value that is not
+     *                      suitable for a production environment.
+     */
+    public function ensureProductionSettings()
+    {
+        $queryCacheImpl = $this->getQueryCacheImpl();
+
+        if ( ! $queryCacheImpl) {
+            throw ORMException::queryCacheNotConfigured();
+        }
+
+        if ($queryCacheImpl instanceof ArrayCache) {
+            throw ORMException::queryCacheUsesNonPersistentCache($queryCacheImpl);
+        }
+
+        $metadataCacheImpl = $this->getMetadataCacheImpl();
+
+        if ( ! $metadataCacheImpl) {
+            throw ORMException::metadataCacheNotConfigured();
+        }
+
+        if ($metadataCacheImpl instanceof ArrayCache) {
+            throw ORMException::metadataCacheUsesNonPersistentCache($metadataCacheImpl);
+        }
+
+        if ($this->getAutoGenerateProxyClasses()) {
+            throw ORMException::proxyClassesAlwaysRegenerating();
+        }
+    }
+
+    /**
+     * Registers a custom DQL function that produces a string value.
+     * Such a function can then be used in any DQL statement in any place where string
+     * functions are allowed.
+     *
+     * DQL function names are case-insensitive.
+     *
+     * @param string          $name      Function name.
+     * @param string|callable $className Class name or a callable that returns the function.
+     *
+     * @return void
+     */
+    public function addCustomStringFunction($name, $className)
+    {
+        $this->_attributes['customStringFunctions'][strtolower($name)] = $className;
+    }
+
+    /**
+     * Gets the implementation class name of a registered custom string DQL function.
+     *
+     * @param string $name
+     *
+     * @return string|null
+     * @psalm-return ?class-string
+     */
+    public function getCustomStringFunction($name)
+    {
+        $name = strtolower($name);
+
+        return isset($this->_attributes['customStringFunctions'][$name])
+            ? $this->_attributes['customStringFunctions'][$name]
+            : null;
+    }
+
+    /**
+     * Sets a map of custom DQL string functions.
+     *
+     * Keys must be function names and values the FQCN of the implementing class.
+     * The function names will be case-insensitive in DQL.
+     *
+     * Any previously added string functions are discarded.
+     *
+     * @param array $functions The map of custom DQL string functions.
+     *
+     * @return void
+     */
+    public function setCustomStringFunctions(array $functions)
+    {
+        foreach ($functions as $name => $className) {
+            $this->addCustomStringFunction($name, $className);
+        }
+    }
+
+    /**
+     * Registers a custom DQL function that produces a numeric value.
+     * Such a function can then be used in any DQL statement in any place where numeric
+     * functions are allowed.
+     *
+     * DQL function names are case-insensitive.
+     *
+     * @param string          $name      Function name.
+     * @param string|callable $className Class name or a callable that returns the function.
+     *
+     * @return void
+     */
+    public function addCustomNumericFunction($name, $className)
+    {
+        $this->_attributes['customNumericFunctions'][strtolower($name)] = $className;
+    }
+
+    /**
+     * Gets the implementation class name of a registered custom numeric DQL function.
+     *
+     * @param string $name
+     *
+     * @return string|null
+     * @psalm-return ?class-string
+     */
+    public function getCustomNumericFunction($name)
+    {
+        $name = strtolower($name);
+
+        return isset($this->_attributes['customNumericFunctions'][$name])
+            ? $this->_attributes['customNumericFunctions'][$name]
+            : null;
+    }
+
+    /**
+     * Sets a map of custom DQL numeric functions.
+     *
+     * Keys must be function names and values the FQCN of the implementing class.
+     * The function names will be case-insensitive in DQL.
+     *
+     * Any previously added numeric functions are discarded.
+     *
+     * @param array $functions The map of custom DQL numeric functions.
+     *
+     * @return void
+     */
+    public function setCustomNumericFunctions(array $functions)
+    {
+        foreach ($functions as $name => $className) {
+            $this->addCustomNumericFunction($name, $className);
+        }
+    }
+
+    /**
+     * Registers a custom DQL function that produces a date/time value.
+     * Such a function can then be used in any DQL statement in any place where date/time
+     * functions are allowed.
+     *
+     * DQL function names are case-insensitive.
+     *
+     * @param string          $name      Function name.
+     * @param string|callable $className Class name or a callable that returns the function.
+     *
+     * @return void
+     *
+     * @psalm-param class-string|callable $className
+     */
+    public function addCustomDatetimeFunction($name, $className)
+    {
+        $this->_attributes['customDatetimeFunctions'][strtolower($name)] = $className;
+    }
+
+    /**
+     * Gets the implementation class name of a registered custom date/time DQL function.
+     *
+     * @param string $name
+     *
+     * @return string|null
+     *
+     * @psalm-return ?class-string $name
+     */
+    public function getCustomDatetimeFunction($name)
+    {
+        $name = strtolower($name);
+
+        return isset($this->_attributes['customDatetimeFunctions'][$name])
+            ? $this->_attributes['customDatetimeFunctions'][$name]
+            : null;
+    }
+
+    /**
+     * Sets a map of custom DQL date/time functions.
+     *
+     * Keys must be function names and values the FQCN of the implementing class.
+     * The function names will be case-insensitive in DQL.
+     *
+     * Any previously added date/time functions are discarded.
+     *
+     * @param array $functions The map of custom DQL date/time functions.
+     *
+     * @return void
+     *
+     * @psalm-param array<string, string> $functions
+     */
+    public function setCustomDatetimeFunctions(array $functions)
+    {
+        foreach ($functions as $name => $className) {
+            $this->addCustomDatetimeFunction($name, $className);
+        }
+    }
+
+    /**
+     * Sets the custom hydrator modes in one pass.
+     *
+     * @param array $modes An array of ($modeName => $hydrator).
+     *
+     * @return void
+     */
+    public function setCustomHydrationModes($modes)
+    {
+        $this->_attributes['customHydrationModes'] = [];
+
+        foreach ($modes as $modeName => $hydrator) {
+            $this->addCustomHydrationMode($modeName, $hydrator);
+        }
+    }
+
+    /**
+     * Gets the hydrator class for the given hydration mode name.
+     *
+     * @param string $modeName The hydration mode name.
+     *
+     * @return string|null The hydrator class name.
+     *
+     * @psalm-return ?class-string
+     */
+    public function getCustomHydrationMode($modeName)
+    {
+        return isset($this->_attributes['customHydrationModes'][$modeName])
+            ? $this->_attributes['customHydrationModes'][$modeName]
+            : null;
+    }
+
+    /**
+     * Adds a custom hydration mode.
+     *
+     * @param string $modeName The hydration mode name.
+     * @param string $hydrator The hydrator class name.
+     *
+     * @return void
+     */
+    public function addCustomHydrationMode($modeName, $hydrator)
+    {
+        $this->_attributes['customHydrationModes'][$modeName] = $hydrator;
+    }
+
+    /**
+     * Sets a class metadata factory.
+     *
+     * @param string $cmfName
+     *
+     * @return void
+     *
+     * @psalm-param class-string $cmfName
+     */
+    public function setClassMetadataFactoryName($cmfName)
+    {
+        $this->_attributes['classMetadataFactoryName'] = $cmfName;
+    }
+
+    /**
+     * @return string
+     *
+     * @psalm-return class-string
+     */
+    public function getClassMetadataFactoryName()
+    {
+        if ( ! isset($this->_attributes['classMetadataFactoryName'])) {
+            $this->_attributes['classMetadataFactoryName'] = ClassMetadataFactory::class;
+        }
+
+        return $this->_attributes['classMetadataFactoryName'];
+    }
+
+    /**
+     * Adds a filter to the list of possible filters.
+     *
+     * @param string $name      The name of the filter.
+     * @param string $className The class name of the filter.
+     */
+    public function addFilter($name, $className)
+    {
+        $this->_attributes['filters'][$name] = $className;
+    }
+
+    /**
+     * Gets the class name for a given filter name.
+     *
+     * @param string $name The name of the filter.
+     *
+     * @return string|null The class name of the filter, or null if it is not
+     *  defined.
+     *
+     * @psalm-return ?class-string
+     */
+    public function getFilterClassName($name)
+    {
+        return isset($this->_attributes['filters'][$name])
+            ? $this->_attributes['filters'][$name]
+            : null;
+    }
+
+    /**
+     * Sets default repository class.
+     *
+     * @since 2.2
+     *
+     * @param string $className
+     *
+     * @return void
+     *
+     * @throws ORMException If $classname is not an ObjectRepository.
+     */
+    public function setDefaultRepositoryClassName($className)
+    {
+        $reflectionClass = new \ReflectionClass($className);
+
+        if ( ! $reflectionClass->implementsInterface(ObjectRepository::class)) {
+            throw ORMException::invalidEntityRepository($className);
+        }
+
+        $this->_attributes['defaultRepositoryClassName'] = $className;
+    }
+
+    /**
+     * Get default repository class.
+     *
+     * @since 2.2
+     *
+     * @return string
+     *
+     * @psalm-return class-string
+     */
+    public function getDefaultRepositoryClassName()
+    {
+        return isset($this->_attributes['defaultRepositoryClassName'])
+            ? $this->_attributes['defaultRepositoryClassName']
+            : EntityRepository::class;
+    }
+
+    /**
+     * Sets naming strategy.
+     *
+     * @since 2.3
+     *
+     * @param NamingStrategy $namingStrategy
+     *
+     * @return void
+     */
+    public function setNamingStrategy(NamingStrategy $namingStrategy)
+    {
+        $this->_attributes['namingStrategy'] = $namingStrategy;
+    }
+
+    /**
+     * Gets naming strategy..
+     *
+     * @since 2.3
+     *
+     * @return NamingStrategy
+     */
+    public function getNamingStrategy()
+    {
+        if ( ! isset($this->_attributes['namingStrategy'])) {
+            $this->_attributes['namingStrategy'] = new DefaultNamingStrategy();
+        }
+
+        return $this->_attributes['namingStrategy'];
+    }
+
+    /**
+     * Sets quote strategy.
+     *
+     * @since 2.3
+     *
+     * @param \Doctrine\ORM\Mapping\QuoteStrategy $quoteStrategy
+     *
+     * @return void
+     */
+    public function setQuoteStrategy(QuoteStrategy $quoteStrategy)
+    {
+        $this->_attributes['quoteStrategy'] = $quoteStrategy;
+    }
+
+    /**
+     * Gets quote strategy.
+     *
+     * @since 2.3
+     *
+     * @return \Doctrine\ORM\Mapping\QuoteStrategy
+     */
+    public function getQuoteStrategy()
+    {
+        if ( ! isset($this->_attributes['quoteStrategy'])) {
+            $this->_attributes['quoteStrategy'] = new DefaultQuoteStrategy();
+        }
+
+        return $this->_attributes['quoteStrategy'];
+    }
+
+    /**
+     * Set the entity listener resolver.
+     *
+     * @since 2.4
+     * @param \Doctrine\ORM\Mapping\EntityListenerResolver $resolver
+     */
+    public function setEntityListenerResolver(EntityListenerResolver $resolver)
+    {
+        $this->_attributes['entityListenerResolver'] = $resolver;
+    }
+
+    /**
+     * Get the entity listener resolver.
+     *
+     * @since 2.4
+     * @return \Doctrine\ORM\Mapping\EntityListenerResolver
+     */
+    public function getEntityListenerResolver()
+    {
+        if ( ! isset($this->_attributes['entityListenerResolver'])) {
+            $this->_attributes['entityListenerResolver'] = new DefaultEntityListenerResolver();
+        }
+
+        return $this->_attributes['entityListenerResolver'];
+    }
+
+    /**
+     * Set the entity repository factory.
+     *
+     * @since 2.4
+     * @param \Doctrine\ORM\Repository\RepositoryFactory $repositoryFactory
+     */
+    public function setRepositoryFactory(RepositoryFactory $repositoryFactory)
+    {
+        $this->_attributes['repositoryFactory'] = $repositoryFactory;
+    }
+
+    /**
+     * Get the entity repository factory.
+     *
+     * @since 2.4
+     * @return \Doctrine\ORM\Repository\RepositoryFactory
+     */
+    public function getRepositoryFactory()
+    {
+        return isset($this->_attributes['repositoryFactory'])
+            ? $this->_attributes['repositoryFactory']
+            : new DefaultRepositoryFactory();
+    }
+
+    /**
+     * @since 2.5
+     *
+     * @return boolean
+     */
+    public function isSecondLevelCacheEnabled()
+    {
+        return isset($this->_attributes['isSecondLevelCacheEnabled'])
+            ? $this->_attributes['isSecondLevelCacheEnabled']
+            : false;
+    }
+
+    /**
+     * @since 2.5
+     *
+     * @param boolean $flag
+     *
+     * @return void
+     */
+    public function setSecondLevelCacheEnabled($flag = true)
+    {
+        $this->_attributes['isSecondLevelCacheEnabled'] = (boolean) $flag;
+    }
+
+    /**
+     * @since 2.5
+     *
+     * @param \Doctrine\ORM\Cache\CacheConfiguration $cacheConfig
+     *
+     * @return void
+     */
+    public function setSecondLevelCacheConfiguration(CacheConfiguration $cacheConfig)
+    {
+        $this->_attributes['secondLevelCacheConfiguration'] = $cacheConfig;
+    }
+
+    /**
+     * @since 2.5
+     *
+     * @return  \Doctrine\ORM\Cache\CacheConfiguration|null
+     */
+    public function getSecondLevelCacheConfiguration()
+    {
+        if ( ! isset($this->_attributes['secondLevelCacheConfiguration']) && $this->isSecondLevelCacheEnabled()) {
+            $this->_attributes['secondLevelCacheConfiguration'] = new CacheConfiguration();
+        }
+
+        return isset($this->_attributes['secondLevelCacheConfiguration'])
+            ? $this->_attributes['secondLevelCacheConfiguration']
+            : null;
+    }
+
+    /**
+     * Returns query hints, which will be applied to every query in application
+     *
+     * @since 2.5
+     *
+     * @return array
+     */
+    public function getDefaultQueryHints()
+    {
+        return isset($this->_attributes['defaultQueryHints']) ? $this->_attributes['defaultQueryHints'] : [];
+    }
+
+    /**
+     * Sets array of query hints, which will be applied to every query in application
+     *
+     * @since 2.5
+     *
+     * @param array $defaultQueryHints
+     */
+    public function setDefaultQueryHints(array $defaultQueryHints)
+    {
+        $this->_attributes['defaultQueryHints'] = $defaultQueryHints;
+    }
+
+    /**
+     * Gets the value of a default query hint. If the hint name is not recognized, FALSE is returned.
+     *
+     * @since 2.5
+     *
+     * @param string $name The name of the hint.
+     *
+     * @return mixed The value of the hint or FALSE, if the hint name is not recognized.
+     */
+    public function getDefaultQueryHint($name)
+    {
+        return isset($this->_attributes['defaultQueryHints'][$name])
+            ? $this->_attributes['defaultQueryHints'][$name]
+            : false;
+    }
+
+    /**
+     * Sets a default query hint. If the hint name is not recognized, it is silently ignored.
+     *
+     * @since 2.5
+     *
+     * @param string $name  The name of the hint.
+     * @param mixed  $value The value of the hint.
+     */
+    public function setDefaultQueryHint($name, $value)
+    {
+        $this->_attributes['defaultQueryHints'][$name] = $value;
+    }
+}
+
+interface_exists(MappingDriver::class);

vendor/doctrine/orm/lib/Doctrine/ORM/Decorator/EntityManagerDecorator.php

@@ -0,0 +1,278 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Decorator;
+
+use Doctrine\ORM\Query\ResultSetMapping;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\Persistence\ObjectManagerDecorator;
+
+/**
+ * Base class for EntityManager decorators
+ *
+ * @since   2.4
+ * @author  Lars Strojny <lars@strojny.net
+ */
+abstract class EntityManagerDecorator extends ObjectManagerDecorator implements EntityManagerInterface
+{
+    /**
+     * @var EntityManagerInterface
+     */
+    protected $wrapped;
+
+    /**
+     * @param EntityManagerInterface $wrapped
+     */
+    public function __construct(EntityManagerInterface $wrapped)
+    {
+        $this->wrapped = $wrapped;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getConnection()
+    {
+        return $this->wrapped->getConnection();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getExpressionBuilder()
+    {
+        return $this->wrapped->getExpressionBuilder();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function beginTransaction()
+    {
+        $this->wrapped->beginTransaction();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function transactional($func)
+    {
+        return $this->wrapped->transactional($func);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function commit()
+    {
+        $this->wrapped->commit();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rollback()
+    {
+        $this->wrapped->rollback();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createQuery($dql = '')
+    {
+        return $this->wrapped->createQuery($dql);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createNamedQuery($name)
+    {
+        return $this->wrapped->createNamedQuery($name);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createNativeQuery($sql, ResultSetMapping $rsm)
+    {
+        return $this->wrapped->createNativeQuery($sql, $rsm);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createNamedNativeQuery($name)
+    {
+        return $this->wrapped->createNamedNativeQuery($name);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createQueryBuilder()
+    {
+        return $this->wrapped->createQueryBuilder();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getReference($entityName, $id)
+    {
+        return $this->wrapped->getReference($entityName, $id);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPartialReference($entityName, $identifier)
+    {
+        return $this->wrapped->getPartialReference($entityName, $identifier);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        $this->wrapped->close();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function copy($entity, $deep = false)
+    {
+        return $this->wrapped->copy($entity, $deep);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function lock($entity, $lockMode, $lockVersion = null)
+    {
+        $this->wrapped->lock($entity, $lockMode, $lockVersion);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function find($className, $id, $lockMode = null, $lockVersion = null)
+    {
+        return $this->wrapped->find($className, $id, $lockMode, $lockVersion);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function flush($entity = null)
+    {
+        $this->wrapped->flush($entity);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getEventManager()
+    {
+        return $this->wrapped->getEventManager();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getConfiguration()
+    {
+        return $this->wrapped->getConfiguration();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isOpen()
+    {
+        return $this->wrapped->isOpen();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getUnitOfWork()
+    {
+        return $this->wrapped->getUnitOfWork();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHydrator($hydrationMode)
+    {
+        return $this->wrapped->getHydrator($hydrationMode);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function newHydrator($hydrationMode)
+    {
+        return $this->wrapped->newHydrator($hydrationMode);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getProxyFactory()
+    {
+        return $this->wrapped->getProxyFactory();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getFilters()
+    {
+        return $this->wrapped->getFilters();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isFiltersStateClean()
+    {
+        return $this->wrapped->isFiltersStateClean();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasFilters()
+    {
+        return $this->wrapped->hasFilters();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCache()
+    {
+        return $this->wrapped->getCache();
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/EntityManager.php

@@ -0,0 +1,963 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+use Doctrine\Common\EventManager;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\DriverManager;
+use Doctrine\DBAL\LockMode;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Query\ResultSetMapping;
+use Doctrine\ORM\Proxy\ProxyFactory;
+use Doctrine\ORM\Query\FilterCollection;
+use Doctrine\Common\Util\ClassUtils;
+use Doctrine\Persistence\Mapping\MappingException;
+use Doctrine\Persistence\ObjectRepository;
+use Throwable;
+use function ltrim;
+use const E_USER_DEPRECATED;
+use function trigger_error;
+
+/**
+ * The EntityManager is the central access point to ORM functionality.
+ *
+ * It is a facade to all different ORM subsystems such as UnitOfWork,
+ * Query Language and Repository API. Instantiation is done through
+ * the static create() method. The quickest way to obtain a fully
+ * configured EntityManager is:
+ *
+ *     use Doctrine\ORM\Tools\Setup;
+ *     use Doctrine\ORM\EntityManager;
+ *
+ *     $paths = array('/path/to/entity/mapping/files');
+ *
+ *     $config = Setup::createAnnotationMetadataConfiguration($paths);
+ *     $dbParams = array('driver' => 'pdo_sqlite', 'memory' => true);
+ *     $entityManager = EntityManager::create($dbParams, $config);
+ *
+ * For more information see
+ * {@link http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/configuration.html}
+ *
+ * You should never attempt to inherit from the EntityManager: Inheritance
+ * is not a valid extension point for the EntityManager. Instead you
+ * should take a look at the {@see \Doctrine\ORM\Decorator\EntityManagerDecorator}
+ * and wrap your entity manager in a decorator.
+ *
+ * @since   2.0
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author  Jonathan Wage <jonwage@gmail.com>
+ * @author  Roman Borschel <roman@code-factory.org>
+ */
+/* final */class EntityManager implements EntityManagerInterface
+{
+    /**
+     * The used Configuration.
+     *
+     * @var \Doctrine\ORM\Configuration
+     */
+    private $config;
+
+    /**
+     * The database connection used by the EntityManager.
+     *
+     * @var \Doctrine\DBAL\Connection
+     */
+    private $conn;
+
+    /**
+     * The metadata factory, used to retrieve the ORM metadata of entity classes.
+     *
+     * @var \Doctrine\ORM\Mapping\ClassMetadataFactory
+     */
+    private $metadataFactory;
+
+    /**
+     * The UnitOfWork used to coordinate object-level transactions.
+     *
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    private $unitOfWork;
+
+    /**
+     * The event manager that is the central point of the event system.
+     *
+     * @var \Doctrine\Common\EventManager
+     */
+    private $eventManager;
+
+    /**
+     * The proxy factory used to create dynamic proxies.
+     *
+     * @var \Doctrine\ORM\Proxy\ProxyFactory
+     */
+    private $proxyFactory;
+
+    /**
+     * The repository factory used to create dynamic repositories.
+     *
+     * @var \Doctrine\ORM\Repository\RepositoryFactory
+     */
+    private $repositoryFactory;
+
+    /**
+     * The expression builder instance used to generate query expressions.
+     *
+     * @var \Doctrine\ORM\Query\Expr
+     */
+    private $expressionBuilder;
+
+    /**
+     * Whether the EntityManager is closed or not.
+     *
+     * @var bool
+     */
+    private $closed = false;
+
+    /**
+     * Collection of query filters.
+     *
+     * @var \Doctrine\ORM\Query\FilterCollection
+     */
+    private $filterCollection;
+
+    /**
+     * @var \Doctrine\ORM\Cache The second level cache regions API.
+     */
+    private $cache;
+
+    /**
+     * Creates a new EntityManager that operates on the given database connection
+     * and uses the given Configuration and EventManager implementations.
+     *
+     * @param \Doctrine\DBAL\Connection     $conn
+     * @param \Doctrine\ORM\Configuration   $config
+     * @param \Doctrine\Common\EventManager $eventManager
+     */
+    protected function __construct(Connection $conn, Configuration $config, EventManager $eventManager)
+    {
+        $this->conn              = $conn;
+        $this->config            = $config;
+        $this->eventManager      = $eventManager;
+
+        $metadataFactoryClassName = $config->getClassMetadataFactoryName();
+
+        $this->metadataFactory = new $metadataFactoryClassName;
+        $this->metadataFactory->setEntityManager($this);
+        $this->metadataFactory->setCacheDriver($this->config->getMetadataCacheImpl());
+
+        $this->repositoryFactory = $config->getRepositoryFactory();
+        $this->unitOfWork        = new UnitOfWork($this);
+        $this->proxyFactory      = new ProxyFactory(
+            $this,
+            $config->getProxyDir(),
+            $config->getProxyNamespace(),
+            $config->getAutoGenerateProxyClasses()
+        );
+
+        if ($config->isSecondLevelCacheEnabled()) {
+            $cacheConfig    = $config->getSecondLevelCacheConfiguration();
+            $cacheFactory   = $cacheConfig->getCacheFactory();
+            $this->cache    = $cacheFactory->createCache($this);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConnection()
+    {
+        return $this->conn;
+    }
+
+    /**
+     * Gets the metadata factory used to gather the metadata of classes.
+     *
+     * @return \Doctrine\ORM\Mapping\ClassMetadataFactory
+     */
+    public function getMetadataFactory()
+    {
+        return $this->metadataFactory;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getExpressionBuilder()
+    {
+        if ($this->expressionBuilder === null) {
+            $this->expressionBuilder = new Query\Expr;
+        }
+
+        return $this->expressionBuilder;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function beginTransaction()
+    {
+        $this->conn->beginTransaction();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getCache()
+    {
+        return $this->cache;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function transactional($func)
+    {
+        if (!is_callable($func)) {
+            throw new \InvalidArgumentException('Expected argument of type "callable", got "' . gettype($func) . '"');
+        }
+
+        $this->conn->beginTransaction();
+
+        try {
+            $return = call_user_func($func, $this);
+
+            $this->flush();
+            $this->conn->commit();
+
+            return $return ?: true;
+        } catch (Throwable $e) {
+            $this->close();
+            $this->conn->rollBack();
+
+            throw $e;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function commit()
+    {
+        $this->conn->commit();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function rollback()
+    {
+        $this->conn->rollBack();
+    }
+
+    /**
+     * Returns the ORM metadata descriptor for a class.
+     *
+     * The class name must be the fully-qualified class name without a leading backslash
+     * (as it is returned by get_class($obj)) or an aliased class name.
+     *
+     * Examples:
+     * MyProject\Domain\User
+     * sales:PriceRequest
+     *
+     * Internal note: Performance-sensitive method.
+     *
+     * @param string $className
+     *
+     * @return \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    public function getClassMetadata($className)
+    {
+        return $this->metadataFactory->getMetadataFor($className);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function createQuery($dql = '')
+    {
+        $query = new Query($this);
+
+        if ( ! empty($dql)) {
+            $query->setDQL($dql);
+        }
+
+        return $query;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function createNamedQuery($name)
+    {
+        return $this->createQuery($this->config->getNamedQuery($name));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function createNativeQuery($sql, ResultSetMapping $rsm)
+    {
+        $query = new NativeQuery($this);
+
+        $query->setSQL($sql);
+        $query->setResultSetMapping($rsm);
+
+        return $query;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function createNamedNativeQuery($name)
+    {
+        [$sql, $rsm] = $this->config->getNamedNativeQuery($name);
+
+        return $this->createNativeQuery($sql, $rsm);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function createQueryBuilder()
+    {
+        return new QueryBuilder($this);
+    }
+
+    /**
+     * Flushes all changes to objects that have been queued up to now to the database.
+     * This effectively synchronizes the in-memory state of managed objects with the
+     * database.
+     *
+     * If an entity is explicitly passed to this method only this entity and
+     * the cascade-persist semantics + scheduled inserts/removals are synchronized.
+     *
+     * @param null|object|array $entity
+     *
+     * @return void
+     *
+     * @throws \Doctrine\ORM\OptimisticLockException If a version check on an entity that
+     *         makes use of optimistic locking fails.
+     * @throws ORMException
+     */
+    public function flush($entity = null)
+    {
+        if ($entity !== null) {
+            @trigger_error(
+                'Calling ' . __METHOD__ . '() with any arguments to flush specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
+                E_USER_DEPRECATED
+            );
+        }
+
+        $this->errorIfClosed();
+
+        $this->unitOfWork->commit($entity);
+    }
+
+    /**
+     * Finds an Entity by its identifier.
+     *
+     * @param string       $className   The class name of the entity to find.
+     * @param mixed        $id          The identity of the entity to find.
+     * @param integer|null $lockMode    One of the \Doctrine\DBAL\LockMode::* constants
+     *                                  or NULL if no specific lock mode should be used
+     *                                  during the search.
+     * @param integer|null $lockVersion The version of the entity to find when using
+     *                                  optimistic locking.
+     *
+     * @return object|null The entity instance or NULL if the entity can not be found.
+     *
+     * @throws OptimisticLockException
+     * @throws ORMInvalidArgumentException
+     * @throws TransactionRequiredException
+     * @throws ORMException
+     */
+    public function find($className, $id, $lockMode = null, $lockVersion = null)
+    {
+        $class = $this->metadataFactory->getMetadataFor(ltrim($className, '\\'));
+
+        if ($lockMode !== null) {
+            $this->checkLockRequirements($lockMode, $class);
+        }
+
+        if ( ! is_array($id)) {
+            if ($class->isIdentifierComposite) {
+                throw ORMInvalidArgumentException::invalidCompositeIdentifier();
+            }
+
+            $id = [$class->identifier[0] => $id];
+        }
+
+        foreach ($id as $i => $value) {
+            if (is_object($value) && $this->metadataFactory->hasMetadataFor(ClassUtils::getClass($value))) {
+                $id[$i] = $this->unitOfWork->getSingleIdentifierValue($value);
+
+                if ($id[$i] === null) {
+                    throw ORMInvalidArgumentException::invalidIdentifierBindingEntity();
+                }
+            }
+        }
+
+        $sortedId = [];
+
+        foreach ($class->identifier as $identifier) {
+            if ( ! isset($id[$identifier])) {
+                throw ORMException::missingIdentifierField($class->name, $identifier);
+            }
+
+            $sortedId[$identifier] = $id[$identifier];
+            unset($id[$identifier]);
+        }
+
+        if ($id) {
+            throw ORMException::unrecognizedIdentifierFields($class->name, array_keys($id));
+        }
+
+        $unitOfWork = $this->getUnitOfWork();
+
+        // Check identity map first
+        if (($entity = $unitOfWork->tryGetById($sortedId, $class->rootEntityName)) !== false) {
+            if ( ! ($entity instanceof $class->name)) {
+                return null;
+            }
+
+            switch (true) {
+                case LockMode::OPTIMISTIC === $lockMode:
+                    $this->lock($entity, $lockMode, $lockVersion);
+                    break;
+
+                case LockMode::NONE === $lockMode:
+                case LockMode::PESSIMISTIC_READ === $lockMode:
+                case LockMode::PESSIMISTIC_WRITE === $lockMode:
+                    $persister = $unitOfWork->getEntityPersister($class->name);
+                    $persister->refresh($sortedId, $entity, $lockMode);
+                    break;
+            }
+
+            return $entity; // Hit!
+        }
+
+        $persister = $unitOfWork->getEntityPersister($class->name);
+
+        switch (true) {
+            case LockMode::OPTIMISTIC === $lockMode:
+                $entity = $persister->load($sortedId);
+
+                $unitOfWork->lock($entity, $lockMode, $lockVersion);
+
+                return $entity;
+
+            case LockMode::PESSIMISTIC_READ === $lockMode:
+            case LockMode::PESSIMISTIC_WRITE === $lockMode:
+                return $persister->load($sortedId, null, null, [], $lockMode);
+
+            default:
+                return $persister->loadById($sortedId);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getReference($entityName, $id)
+    {
+        $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
+
+        if ( ! is_array($id)) {
+            $id = [$class->identifier[0] => $id];
+        }
+
+        $sortedId = [];
+
+        foreach ($class->identifier as $identifier) {
+            if ( ! isset($id[$identifier])) {
+                throw ORMException::missingIdentifierField($class->name, $identifier);
+            }
+
+            $sortedId[$identifier] = $id[$identifier];
+            unset($id[$identifier]);
+        }
+
+        if ($id) {
+            throw ORMException::unrecognizedIdentifierFields($class->name, array_keys($id));
+        }
+
+        // Check identity map first, if its already in there just return it.
+        if (($entity = $this->unitOfWork->tryGetById($sortedId, $class->rootEntityName)) !== false) {
+            return ($entity instanceof $class->name) ? $entity : null;
+        }
+
+        if ($class->subClasses) {
+            return $this->find($entityName, $sortedId);
+        }
+
+        $entity = $this->proxyFactory->getProxy($class->name, $sortedId);
+
+        $this->unitOfWork->registerManaged($entity, $sortedId, []);
+
+        return $entity;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getPartialReference($entityName, $identifier)
+    {
+        $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
+
+        // Check identity map first, if its already in there just return it.
+        if (($entity = $this->unitOfWork->tryGetById($identifier, $class->rootEntityName)) !== false) {
+            return ($entity instanceof $class->name) ? $entity : null;
+        }
+
+        if ( ! is_array($identifier)) {
+            $identifier = [$class->identifier[0] => $identifier];
+        }
+
+        $entity = $class->newInstance();
+
+        $class->setIdentifierValues($entity, $identifier);
+
+        $this->unitOfWork->registerManaged($entity, $identifier, []);
+        $this->unitOfWork->markReadOnly($entity);
+
+        return $entity;
+    }
+
+    /**
+     * Clears the EntityManager. All entities that are currently managed
+     * by this EntityManager become detached.
+     *
+     * @param string|null $entityName if given, only entities of this type will get detached
+     *
+     * @return void
+     *
+     * @throws ORMInvalidArgumentException If a non-null non-string value is given.
+     * @throws MappingException            If a $entityName is given, but that entity is not
+     *                                     found in the mappings.
+     */
+    public function clear($entityName = null)
+    {
+        if (null !== $entityName && ! is_string($entityName)) {
+            throw ORMInvalidArgumentException::invalidEntityName($entityName);
+        }
+
+        if ($entityName !== null) {
+            @trigger_error(
+                'Calling ' . __METHOD__ . '() with any arguments to clear specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
+                E_USER_DEPRECATED
+            );
+        }
+
+        $this->unitOfWork->clear(
+            null === $entityName
+                ? null
+                : $this->metadataFactory->getMetadataFor($entityName)->getName()
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function close()
+    {
+        $this->clear();
+
+        $this->closed = true;
+    }
+
+    /**
+     * Tells the EntityManager to make an instance managed and persistent.
+     *
+     * The entity will be entered into the database at or before transaction
+     * commit or as a result of the flush operation.
+     *
+     * NOTE: The persist operation always considers entities that are not yet known to
+     * this EntityManager as NEW. Do not pass detached entities to the persist operation.
+     *
+     * @param object $entity The instance to make managed and persistent.
+     *
+     * @return void
+     *
+     * @throws ORMInvalidArgumentException
+     * @throws ORMException
+     */
+    public function persist($entity)
+    {
+        if ( ! is_object($entity)) {
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#persist()', $entity);
+        }
+
+        $this->errorIfClosed();
+
+        $this->unitOfWork->persist($entity);
+    }
+
+    /**
+     * Removes an entity instance.
+     *
+     * A removed entity will be removed from the database at or before transaction commit
+     * or as a result of the flush operation.
+     *
+     * @param object $entity The entity instance to remove.
+     *
+     * @return void
+     *
+     * @throws ORMInvalidArgumentException
+     * @throws ORMException
+     */
+    public function remove($entity)
+    {
+        if ( ! is_object($entity)) {
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#remove()', $entity);
+        }
+
+        $this->errorIfClosed();
+
+        $this->unitOfWork->remove($entity);
+    }
+
+    /**
+     * Refreshes the persistent state of an entity from the database,
+     * overriding any local changes that have not yet been persisted.
+     *
+     * @param object $entity The entity to refresh.
+     *
+     * @return void
+     *
+     * @throws ORMInvalidArgumentException
+     * @throws ORMException
+     */
+    public function refresh($entity)
+    {
+        if ( ! is_object($entity)) {
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#refresh()', $entity);
+        }
+
+        $this->errorIfClosed();
+
+        $this->unitOfWork->refresh($entity);
+    }
+
+    /**
+     * Detaches an entity from the EntityManager, causing a managed entity to
+     * become detached.  Unflushed changes made to the entity if any
+     * (including removal of the entity), will not be synchronized to the database.
+     * Entities which previously referenced the detached entity will continue to
+     * reference it.
+     *
+     * @param object $entity The entity to detach.
+     *
+     * @return void
+     *
+     * @throws ORMInvalidArgumentException
+     *
+     * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
+     */
+    public function detach($entity)
+    {
+        @trigger_error('Method ' . __METHOD__ . '() is deprecated and will be removed in Doctrine ORM 3.0.', E_USER_DEPRECATED);
+
+        if ( ! is_object($entity)) {
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#detach()', $entity);
+        }
+
+        $this->unitOfWork->detach($entity);
+    }
+
+    /**
+     * Merges the state of a detached entity into the persistence context
+     * of this EntityManager and returns the managed copy of the entity.
+     * The entity passed to merge will not become associated/managed with this EntityManager.
+     *
+     * @param object $entity The detached entity to merge into the persistence context.
+     *
+     * @return object The managed copy of the entity.
+     *
+     * @throws ORMInvalidArgumentException
+     * @throws ORMException
+     *
+     * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
+     */
+    public function merge($entity)
+    {
+        @trigger_error('Method ' . __METHOD__ . '() is deprecated and will be removed in Doctrine ORM 3.0.', E_USER_DEPRECATED);
+
+        if ( ! is_object($entity)) {
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#merge()', $entity);
+        }
+
+        $this->errorIfClosed();
+
+        return $this->unitOfWork->merge($entity);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function copy($entity, $deep = false)
+    {
+        @trigger_error('Method ' . __METHOD__ . '() is deprecated and will be removed in Doctrine ORM 3.0.', E_USER_DEPRECATED);
+
+        throw new \BadMethodCallException("Not implemented.");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function lock($entity, $lockMode, $lockVersion = null)
+    {
+        $this->unitOfWork->lock($entity, $lockMode, $lockVersion);
+    }
+
+    /**
+     * Gets the repository for an entity class.
+     *
+     * @param string $entityName The name of the entity.
+     *
+     * @return ObjectRepository|EntityRepository The repository class.
+     */
+    public function getRepository($entityName)
+    {
+        return $this->repositoryFactory->getRepository($this, $entityName);
+    }
+
+    /**
+     * Determines whether an entity instance is managed in this EntityManager.
+     *
+     * @param object $entity
+     *
+     * @return boolean TRUE if this EntityManager currently manages the given entity, FALSE otherwise.
+     */
+    public function contains($entity)
+    {
+        return $this->unitOfWork->isScheduledForInsert($entity)
+            || $this->unitOfWork->isInIdentityMap($entity)
+            && ! $this->unitOfWork->isScheduledForDelete($entity);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getEventManager()
+    {
+        return $this->eventManager;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConfiguration()
+    {
+        return $this->config;
+    }
+
+    /**
+     * Throws an exception if the EntityManager is closed or currently not active.
+     *
+     * @return void
+     *
+     * @throws ORMException If the EntityManager is closed.
+     */
+    private function errorIfClosed()
+    {
+        if ($this->closed) {
+            throw ORMException::entityManagerClosed();
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isOpen()
+    {
+        return (!$this->closed);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getUnitOfWork()
+    {
+        return $this->unitOfWork;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getHydrator($hydrationMode)
+    {
+        return $this->newHydrator($hydrationMode);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function newHydrator($hydrationMode)
+    {
+        switch ($hydrationMode) {
+            case Query::HYDRATE_OBJECT:
+                return new Internal\Hydration\ObjectHydrator($this);
+
+            case Query::HYDRATE_ARRAY:
+                return new Internal\Hydration\ArrayHydrator($this);
+
+            case Query::HYDRATE_SCALAR:
+                return new Internal\Hydration\ScalarHydrator($this);
+
+            case Query::HYDRATE_SINGLE_SCALAR:
+                return new Internal\Hydration\SingleScalarHydrator($this);
+
+            case Query::HYDRATE_SIMPLEOBJECT:
+                return new Internal\Hydration\SimpleObjectHydrator($this);
+
+            default:
+                if (($class = $this->config->getCustomHydrationMode($hydrationMode)) !== null) {
+                    return new $class($this);
+                }
+        }
+
+        throw ORMException::invalidHydrationMode($hydrationMode);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getProxyFactory()
+    {
+        return $this->proxyFactory;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function initializeObject($obj)
+    {
+        $this->unitOfWork->initializeObject($obj);
+    }
+
+    /**
+     * Factory method to create EntityManager instances.
+     *
+     * @param array|Connection $connection   An array with the connection parameters or an existing Connection instance.
+     * @param Configuration    $config       The Configuration instance to use.
+     * @param EventManager     $eventManager The EventManager instance to use.
+     *
+     * @return EntityManager The created EntityManager.
+     *
+     * @throws \InvalidArgumentException
+     * @throws ORMException
+     */
+    public static function create($connection, Configuration $config, EventManager $eventManager = null)
+    {
+        if ( ! $config->getMetadataDriverImpl()) {
+            throw ORMException::missingMappingDriverImpl();
+        }
+
+        $connection = static::createConnection($connection, $config, $eventManager);
+
+        return new EntityManager($connection, $config, $connection->getEventManager());
+    }
+
+    /**
+     * Factory method to create Connection instances.
+     *
+     * @param array|Connection $connection   An array with the connection parameters or an existing Connection instance.
+     * @param Configuration    $config       The Configuration instance to use.
+     * @param EventManager     $eventManager The EventManager instance to use.
+     *
+     * @return Connection
+     *
+     * @throws \InvalidArgumentException
+     * @throws ORMException
+     */
+    protected static function createConnection($connection, Configuration $config, EventManager $eventManager = null)
+    {
+        if (is_array($connection)) {
+            return DriverManager::getConnection($connection, $config, $eventManager ?: new EventManager());
+        }
+
+        if ( ! $connection instanceof Connection) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    'Invalid $connection argument of type %s given%s.',
+                    is_object($connection) ? get_class($connection) : gettype($connection),
+                    is_object($connection) ? '' : ': "' . $connection . '"'
+                )
+            );
+        }
+
+        if ($eventManager !== null && $connection->getEventManager() !== $eventManager) {
+            throw ORMException::mismatchedEventManager();
+        }
+
+        return $connection;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getFilters()
+    {
+        if (null === $this->filterCollection) {
+            $this->filterCollection = new FilterCollection($this);
+        }
+
+        return $this->filterCollection;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isFiltersStateClean()
+    {
+        return null === $this->filterCollection || $this->filterCollection->isClean();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasFilters()
+    {
+        return null !== $this->filterCollection;
+    }
+
+    /**
+     * @param int $lockMode
+     * @param ClassMetadata $class
+     * @throws OptimisticLockException
+     * @throws TransactionRequiredException
+     */
+    private function checkLockRequirements(int $lockMode, ClassMetadata $class): void
+    {
+        switch ($lockMode) {
+            case LockMode::OPTIMISTIC:
+                if (!$class->isVersioned) {
+                    throw OptimisticLockException::notVersioned($class->name);
+                }
+                break;
+            case LockMode::PESSIMISTIC_READ:
+            case LockMode::PESSIMISTIC_WRITE:
+                if (!$this->getConnection()->isTransactionActive()) {
+                    throw TransactionRequiredException::transactionRequired();
+                }
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/EntityManagerInterface.php

@@ -0,0 +1,298 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+use Doctrine\ORM\Query\ResultSetMapping;
+use Doctrine\Persistence\ObjectManager;
+
+/**
+ * EntityManager interface
+ *
+ * @since   2.4
+ * @author  Lars Strojny <lars@strojny.net>
+ *
+ * @method Mapping\ClassMetadata getClassMetadata($className)
+ */
+interface EntityManagerInterface extends ObjectManager
+{
+    /**
+     * Returns the cache API for managing the second level cache regions or NULL if the cache is not enabled.
+     *
+     * @return \Doctrine\ORM\Cache|null
+     */
+    public function getCache();
+
+    /**
+     * Gets the database connection object used by the EntityManager.
+     *
+     * @return \Doctrine\DBAL\Connection
+     */
+    public function getConnection();
+
+    /**
+     * Gets an ExpressionBuilder used for object-oriented construction of query expressions.
+     *
+     * Example:
+     *
+     * <code>
+     *     $qb = $em->createQueryBuilder();
+     *     $expr = $em->getExpressionBuilder();
+     *     $qb->select('u')->from('User', 'u')
+     *         ->where($expr->orX($expr->eq('u.id', 1), $expr->eq('u.id', 2)));
+     * </code>
+     *
+     * @return \Doctrine\ORM\Query\Expr
+     */
+    public function getExpressionBuilder();
+
+    /**
+     * Starts a transaction on the underlying database connection.
+     *
+     * @return void
+     */
+    public function beginTransaction();
+
+    /**
+     * Executes a function in a transaction.
+     *
+     * The function gets passed this EntityManager instance as an (optional) parameter.
+     *
+     * {@link flush} is invoked prior to transaction commit.
+     *
+     * If an exception occurs during execution of the function or flushing or transaction commit,
+     * the transaction is rolled back, the EntityManager closed and the exception re-thrown.
+     *
+     * @param callable $func The function to execute transactionally.
+     *
+     * @return mixed The non-empty value returned from the closure or true instead.
+     */
+    public function transactional($func);
+
+    /**
+     * Commits a transaction on the underlying database connection.
+     *
+     * @return void
+     */
+    public function commit();
+
+    /**
+     * Performs a rollback on the underlying database connection.
+     *
+     * @return void
+     */
+    public function rollback();
+
+    /**
+     * Creates a new Query object.
+     *
+     * @param string $dql The DQL string.
+     *
+     * @return Query
+     */
+    public function createQuery($dql = '');
+
+    /**
+     * Creates a Query from a named query.
+     *
+     * @param string $name
+     *
+     * @return Query
+     */
+    public function createNamedQuery($name);
+
+    /**
+     * Creates a native SQL query.
+     *
+     * @param string           $sql
+     * @param ResultSetMapping $rsm The ResultSetMapping to use.
+     *
+     * @return NativeQuery
+     */
+    public function createNativeQuery($sql, ResultSetMapping $rsm);
+
+    /**
+     * Creates a NativeQuery from a named native query.
+     *
+     * @param string $name
+     *
+     * @return NativeQuery
+     */
+    public function createNamedNativeQuery($name);
+
+    /**
+     * Create a QueryBuilder instance
+     *
+     * @return QueryBuilder
+     */
+    public function createQueryBuilder();
+
+    /**
+     * Gets a reference to the entity identified by the given type and identifier
+     * without actually loading it, if the entity is not yet loaded.
+     *
+     * @param string $entityName The name of the entity type.
+     * @param mixed  $id         The entity identifier.
+     *
+     * @return object|null The entity reference.
+     *
+     * @throws ORMException
+     */
+    public function getReference($entityName, $id);
+
+    /**
+     * Gets a partial reference to the entity identified by the given type and identifier
+     * without actually loading it, if the entity is not yet loaded.
+     *
+     * The returned reference may be a partial object if the entity is not yet loaded/managed.
+     * If it is a partial object it will not initialize the rest of the entity state on access.
+     * Thus you can only ever safely access the identifier of an entity obtained through
+     * this method.
+     *
+     * The use-cases for partial references involve maintaining bidirectional associations
+     * without loading one side of the association or to update an entity without loading it.
+     * Note, however, that in the latter case the original (persistent) entity data will
+     * never be visible to the application (especially not event listeners) as it will
+     * never be loaded in the first place.
+     *
+     * @param string $entityName The name of the entity type.
+     * @param mixed  $identifier The entity identifier.
+     *
+     * @return object|null The (partial) entity reference.
+     */
+    public function getPartialReference($entityName, $identifier);
+
+    /**
+     * Closes the EntityManager. All entities that are currently managed
+     * by this EntityManager become detached. The EntityManager may no longer
+     * be used after it is closed.
+     *
+     * @return void
+     */
+    public function close();
+
+    /**
+     * Creates a copy of the given entity. Can create a shallow or a deep copy.
+     *
+     * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
+     *
+     * @param object  $entity The entity to copy.
+     * @param boolean $deep   FALSE for a shallow copy, TRUE for a deep copy.
+     *
+     * @return object The new entity.
+     *
+     * @throws \BadMethodCallException
+     */
+    public function copy($entity, $deep = false);
+
+    /**
+     * Acquire a lock on the given entity.
+     *
+     * @param object   $entity
+     * @param int      $lockMode
+     * @param int|null $lockVersion
+     *
+     * @return void
+     *
+     * @throws OptimisticLockException
+     * @throws PessimisticLockException
+     */
+    public function lock($entity, $lockMode, $lockVersion = null);
+
+    /**
+     * Gets the EventManager used by the EntityManager.
+     *
+     * @return \Doctrine\Common\EventManager
+     */
+    public function getEventManager();
+
+    /**
+     * Gets the Configuration used by the EntityManager.
+     *
+     * @return Configuration
+     */
+    public function getConfiguration();
+
+    /**
+     * Check if the Entity manager is open or closed.
+     *
+     * @return bool
+     */
+    public function isOpen();
+
+    /**
+     * Gets the UnitOfWork used by the EntityManager to coordinate operations.
+     *
+     * @return UnitOfWork
+     */
+    public function getUnitOfWork();
+
+    /**
+    * Gets a hydrator for the given hydration mode.
+    *
+    * This method caches the hydrator instances which is used for all queries that don't
+    * selectively iterate over the result.
+    *
+    * @deprecated
+    *
+    * @param string|int $hydrationMode
+    *
+    * @return \Doctrine\ORM\Internal\Hydration\AbstractHydrator
+    */
+    public function getHydrator($hydrationMode);
+
+    /**
+     * Create a new instance for the given hydration mode.
+     *
+     * @param string|int $hydrationMode
+     *
+     * @return \Doctrine\ORM\Internal\Hydration\AbstractHydrator
+     *
+     * @throws ORMException
+     */
+    public function newHydrator($hydrationMode);
+
+    /**
+     * Gets the proxy factory used by the EntityManager to create entity proxies.
+     *
+     * @return \Doctrine\ORM\Proxy\ProxyFactory
+     */
+    public function getProxyFactory();
+
+    /**
+     * Gets the enabled filters.
+     *
+     * @return \Doctrine\ORM\Query\FilterCollection The active filter collection.
+     */
+    public function getFilters();
+
+    /**
+     * Checks whether the state of the filter collection is clean.
+     *
+     * @return boolean True, if the filter collection is clean.
+     */
+    public function isFiltersStateClean();
+
+    /**
+     * Checks whether the Entity Manager has filters.
+     *
+     * @return boolean True, if the EM has a filter collection.
+     */
+    public function hasFilters();
+}

vendor/doctrine/orm/lib/Doctrine/ORM/EntityNotFoundException.php

@@ -0,0 +1,51 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+/**
+ * Exception thrown when a Proxy fails to retrieve an Entity result.
+ *
+ * @author robo
+ * @since 2.0
+ */
+class EntityNotFoundException extends ORMException
+{
+    /**
+     * Static constructor.
+     *
+     * @param string   $className
+     * @param string[] $id
+     *
+     * @return self
+     */
+    public static function fromClassNameAndIdentifier($className, array $id)
+    {
+        $ids = [];
+
+        foreach ($id as $key => $value) {
+            $ids[] = $key . '(' . $value . ')';
+        }
+
+
+        return new self(
+            'Entity of type \'' . $className . '\'' . ($ids ? ' for IDs ' . implode(', ', $ids) : '') . ' was not found'
+        );
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/EntityRepository.php

@@ -0,0 +1,313 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+use Doctrine\Common\Collections\Criteria;
+use Doctrine\Common\Collections\Selectable;
+use Doctrine\Common\Inflector\Inflector;
+use Doctrine\ORM\Query\ResultSetMappingBuilder;
+use Doctrine\Persistence\ObjectRepository;
+
+/**
+ * An EntityRepository serves as a repository for entities with generic as well as
+ * business specific methods for retrieving entities.
+ *
+ * This class is designed for inheritance and users can subclass this class to
+ * write their own repositories with business-specific methods to locate entities.
+ *
+ * @since   2.0
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author  Jonathan Wage <jonwage@gmail.com>
+ * @author  Roman Borschel <roman@code-factory.org>
+ */
+class EntityRepository implements ObjectRepository, Selectable
+{
+    /**
+     * @var string
+     */
+    protected $_entityName;
+
+    /**
+     * @var EntityManager
+     */
+    protected $_em;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    protected $_class;
+
+    /**
+     * Initializes a new <tt>EntityRepository</tt>.
+     */
+    public function __construct(EntityManagerInterface $em, Mapping\ClassMetadata $class)
+    {
+        $this->_entityName = $class->name;
+        $this->_em         = $em;
+        $this->_class      = $class;
+    }
+
+    /**
+     * Creates a new QueryBuilder instance that is prepopulated for this entity name.
+     *
+     * @param string $alias
+     * @param string $indexBy The index for the from.
+     *
+     * @return QueryBuilder
+     */
+    public function createQueryBuilder($alias, $indexBy = null)
+    {
+        return $this->_em->createQueryBuilder()
+            ->select($alias)
+            ->from($this->_entityName, $alias, $indexBy);
+    }
+
+    /**
+     * Creates a new result set mapping builder for this entity.
+     *
+     * The column naming strategy is "INCREMENT".
+     *
+     * @param string $alias
+     *
+     * @return ResultSetMappingBuilder
+     */
+    public function createResultSetMappingBuilder($alias)
+    {
+        $rsm = new ResultSetMappingBuilder($this->_em, ResultSetMappingBuilder::COLUMN_RENAMING_INCREMENT);
+        $rsm->addRootEntityFromClassMetadata($this->_entityName, $alias);
+
+        return $rsm;
+    }
+
+    /**
+     * Creates a new Query instance based on a predefined metadata named query.
+     *
+     * @param string $queryName
+     *
+     * @return Query
+     */
+    public function createNamedQuery($queryName)
+    {
+        return $this->_em->createQuery($this->_class->getNamedQuery($queryName));
+    }
+
+    /**
+     * Creates a native SQL query.
+     *
+     * @param string $queryName
+     *
+     * @return NativeQuery
+     */
+    public function createNativeNamedQuery($queryName)
+    {
+        $queryMapping   = $this->_class->getNamedNativeQuery($queryName);
+        $rsm            = new Query\ResultSetMappingBuilder($this->_em);
+        $rsm->addNamedNativeQueryMapping($this->_class, $queryMapping);
+
+        return $this->_em->createNativeQuery($queryMapping['query'], $rsm);
+    }
+
+    /**
+     * Clears the repository, causing all managed entities to become detached.
+     *
+     * @return void
+     */
+    public function clear()
+    {
+        $this->_em->clear($this->_class->rootEntityName);
+    }
+
+    /**
+     * Finds an entity by its primary key / identifier.
+     *
+     * @param mixed    $id          The identifier.
+     * @param int|null $lockMode    One of the \Doctrine\DBAL\LockMode::* constants
+     *                              or NULL if no specific lock mode should be used
+     *                              during the search.
+     * @param int|null $lockVersion The lock version.
+     *
+     * @return object|null The entity instance or NULL if the entity can not be found.
+     */
+    public function find($id, $lockMode = null, $lockVersion = null)
+    {
+        return $this->_em->find($this->_entityName, $id, $lockMode, $lockVersion);
+    }
+
+    /**
+     * Finds all entities in the repository.
+     *
+     * @return array The entities.
+     */
+    public function findAll()
+    {
+        return $this->findBy([]);
+    }
+
+    /**
+     * Finds entities by a set of criteria.
+     *
+     * @param array      $criteria
+     * @param array|null $orderBy
+     * @param int|null   $limit
+     * @param int|null   $offset
+     *
+     * @return array The objects.
+     */
+    public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+    {
+        $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
+
+        return $persister->loadAll($criteria, $orderBy, $limit, $offset);
+    }
+
+    /**
+     * Finds a single entity by a set of criteria.
+     *
+     * @param array      $criteria
+     * @param array|null $orderBy
+     *
+     * @return object|null The entity instance or NULL if the entity can not be found.
+     */
+    public function findOneBy(array $criteria, array $orderBy = null)
+    {
+        $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
+
+        return $persister->load($criteria, null, null, [], null, 1, $orderBy);
+    }
+
+    /**
+     * Counts entities by a set of criteria.
+     *
+     * @todo Add this method to `ObjectRepository` interface in the next major release
+     *
+     * @param array $criteria
+     *
+     * @return int The cardinality of the objects that match the given criteria.
+     */
+    public function count(array $criteria)
+    {
+        return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->count($criteria);
+    }
+
+    /**
+     * Adds support for magic method calls.
+     *
+     * @param string $method
+     * @param array  $arguments
+     *
+     * @return mixed The returned value from the resolved method.
+     *
+     * @throws ORMException
+     * @throws \BadMethodCallException If the method called is invalid
+     */
+    public function __call($method, $arguments)
+    {
+        if (0 === strpos($method, 'findBy')) {
+            return $this->resolveMagicCall('findBy', substr($method, 6), $arguments);
+        }
+
+        if (0 === strpos($method, 'findOneBy')) {
+            return $this->resolveMagicCall('findOneBy', substr($method, 9), $arguments);
+        }
+
+        if (0 === strpos($method, 'countBy')) {
+            return $this->resolveMagicCall('count', substr($method, 7), $arguments);
+        }
+
+        throw new \BadMethodCallException(
+            "Undefined method '$method'. The method name must start with ".
+            "either findBy, findOneBy or countBy!"
+        );
+    }
+
+    /**
+     * @return string
+     */
+    protected function getEntityName()
+    {
+        return $this->_entityName;
+    }
+
+    /**
+     * @return string
+     */
+    public function getClassName()
+    {
+        return $this->getEntityName();
+    }
+
+    /**
+     * @return EntityManager
+     */
+    protected function getEntityManager()
+    {
+        return $this->_em;
+    }
+
+    /**
+     * @return Mapping\ClassMetadata
+     */
+    protected function getClassMetadata()
+    {
+        return $this->_class;
+    }
+
+    /**
+     * Select all elements from a selectable that match the expression and
+     * return a new collection containing these elements.
+     *
+     * @param \Doctrine\Common\Collections\Criteria $criteria
+     *
+     * @return \Doctrine\Common\Collections\Collection
+     */
+    public function matching(Criteria $criteria)
+    {
+        $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
+
+        return new LazyCriteriaCollection($persister, $criteria);
+    }
+
+    /**
+     * Resolves a magic method call to the proper existent method at `EntityRepository`.
+     *
+     * @param string $method    The method to call
+     * @param string $by        The property name used as condition
+     * @param array  $arguments The arguments to pass at method call
+     *
+     * @throws ORMException If the method called is invalid or the requested field/association does not exist
+     *
+     * @return mixed
+     */
+    private function resolveMagicCall($method, $by, array $arguments)
+    {
+        if (! $arguments) {
+            throw ORMException::findByRequiresParameter($method . $by);
+        }
+
+        $fieldName = lcfirst(Inflector::classify($by));
+
+        if (! ($this->_class->hasField($fieldName) || $this->_class->hasAssociation($fieldName))) {
+            throw ORMException::invalidMagicCall($this->_entityName, $fieldName, $method . $by);
+        }
+
+        return $this->$method([$fieldName => $arguments[0]], ...array_slice($arguments, 1));
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/LifecycleEventArgs.php

@@ -0,0 +1,54 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Persistence\Event\LifecycleEventArgs as BaseLifecycleEventArgs;
+
+/**
+ * Lifecycle Events are triggered by the UnitOfWork during lifecycle transitions
+ * of entities.
+ *
+ * @link   www.doctrine-project.org
+ * @since  2.0
+ * @author Roman Borschel <roman@code-factory.de>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class LifecycleEventArgs extends BaseLifecycleEventArgs
+{
+    /**
+     * Retrieves associated Entity.
+     *
+     * @return object
+     */
+    public function getEntity()
+    {
+        return $this->getObject();
+    }
+
+    /**
+     * Retrieves associated EntityManager.
+     *
+     * @return \Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->getObjectManager();
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/ListenersInvoker.php

@@ -0,0 +1,120 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Common\EventArgs;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+/**
+ * A method invoker based on entity lifecycle.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.4
+ */
+class ListenersInvoker
+{
+    const INVOKE_NONE       = 0;
+    const INVOKE_LISTENERS  = 1;
+    const INVOKE_CALLBACKS  = 2;
+    const INVOKE_MANAGER    = 4;
+
+    /**
+     * @var \Doctrine\ORM\Mapping\EntityListenerResolver The Entity listener resolver.
+     */
+    private $resolver;
+
+    /**
+     * The EventManager used for dispatching events.
+     *
+     * @var \Doctrine\Common\EventManager
+     */
+    private $eventManager;
+
+    /**
+     * Initializes a new ListenersInvoker instance.
+     *
+     * @param EntityManagerInterface $em
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->eventManager = $em->getEventManager();
+        $this->resolver     = $em->getConfiguration()->getEntityListenerResolver();
+    }
+
+    /**
+     * Get the subscribed event systems
+     *
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata  The entity metadata.
+     * @param string                              $eventName The entity lifecycle event.
+     *
+     * @return integer Bitmask of subscribed event systems.
+     */
+    public function getSubscribedSystems(ClassMetadata $metadata, $eventName)
+    {
+        $invoke = self::INVOKE_NONE;
+
+        if (isset($metadata->lifecycleCallbacks[$eventName])) {
+            $invoke |= self::INVOKE_CALLBACKS;
+        }
+
+        if (isset($metadata->entityListeners[$eventName])) {
+            $invoke |= self::INVOKE_LISTENERS;
+        }
+
+        if ($this->eventManager->hasListeners($eventName)) {
+            $invoke |= self::INVOKE_MANAGER;
+        }
+
+        return $invoke;
+    }
+
+    /**
+     * Dispatches the lifecycle event of the given entity.
+     *
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata  The entity metadata.
+     * @param string                              $eventName The entity lifecycle event.
+     * @param object                              $entity    The Entity on which the event occurred.
+     * @param \Doctrine\Common\EventArgs          $event     The Event args.
+     * @param integer                             $invoke    Bitmask to invoke listeners.
+     */
+    public function invoke(ClassMetadata $metadata, $eventName, $entity, EventArgs $event, $invoke)
+    {
+        if ($invoke & self::INVOKE_CALLBACKS) {
+            foreach ($metadata->lifecycleCallbacks[$eventName] as $callback) {
+                $entity->$callback($event);
+            }
+        }
+
+        if ($invoke & self::INVOKE_LISTENERS) {
+            foreach ($metadata->entityListeners[$eventName] as $listener) {
+                $class      = $listener['class'];
+                $method     = $listener['method'];
+                $instance   = $this->resolver->resolve($class);
+
+                $instance->$method($entity, $event);
+            }
+        }
+
+        if ($invoke & self::INVOKE_MANAGER) {
+            $this->eventManager->dispatchEvent($eventName, $event);
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/LoadClassMetadataEventArgs.php

@@ -0,0 +1,46 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Persistence\Event\LoadClassMetadataEventArgs as BaseLoadClassMetadataEventArgs;
+
+/**
+ * Class that holds event arguments for a loadMetadata event.
+ *
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @since  2.0
+ *
+ * Note: method annotations are used instead of method overrides (due to BC policy)
+ *
+ * @method __construct(\Doctrine\ORM\Mapping\ClassMetadata $classMetadata, \Doctrine\ORM\EntityManager $objectManager)
+ * @method \Doctrine\ORM\Mapping\ClassMetadata getClassMetadata()
+ */
+class LoadClassMetadataEventArgs extends BaseLoadClassMetadataEventArgs
+{
+    /**
+     * Retrieve associated EntityManager.
+     *
+     * @return \Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->getObjectManager();
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/OnClassMetadataNotFoundEventArgs.php

@@ -0,0 +1,88 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Persistence\Event\ManagerEventArgs;
+use Doctrine\Persistence\Mapping\ClassMetadata;
+use Doctrine\Persistence\ObjectManager;
+use function interface_exists;
+
+/**
+ * Class that holds event arguments for a `onClassMetadataNotFound` event.
+ *
+ * This object is mutable by design, allowing callbacks having access to it to set the
+ * found metadata in it, and therefore "cancelling" a `onClassMetadataNotFound` event
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @since  2.5
+ */
+class OnClassMetadataNotFoundEventArgs extends ManagerEventArgs
+{
+    /**
+     * @var string
+     */
+    private $className;
+
+    /**
+     * @var ClassMetadata|null
+     */
+    private $foundMetadata;
+
+    /**
+     * Constructor.
+     *
+     * @param string        $className
+     * @param ObjectManager $objectManager
+     */
+    public function __construct($className, ObjectManager $objectManager)
+    {
+        $this->className = (string) $className;
+
+        parent::__construct($objectManager);
+    }
+
+    /**
+     * @param ClassMetadata|null $classMetadata
+     */
+    public function setFoundMetadata(ClassMetadata $classMetadata = null)
+    {
+        $this->foundMetadata = $classMetadata;
+    }
+
+    /**
+     * @return ClassMetadata|null
+     */
+    public function getFoundMetadata()
+    {
+        return $this->foundMetadata;
+    }
+
+    /**
+     * Retrieve class name for which a failed metadata fetch attempt was executed
+     *
+     * @return string
+     */
+    public function getClassName()
+    {
+        return $this->className;
+    }
+}
+
+interface_exists(ClassMetadata::class);

vendor/doctrine/orm/lib/Doctrine/ORM/Event/OnClearEventArgs.php

@@ -0,0 +1,86 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Provides event arguments for the onClear event.
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.org
+ * @since       2.0
+ * @author      Roman Borschel <roman@code-factory.de>
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class OnClearEventArgs extends \Doctrine\Common\EventArgs
+{
+    /**
+     * @var EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * @var string|null
+     */
+    private $entityClass;
+
+    /**
+     * Constructor.
+     *
+     * @param EntityManagerInterface $em
+     * @param string|null            $entityClass Optional entity class.
+     */
+    public function __construct(EntityManagerInterface $em, $entityClass = null)
+    {
+        $this->em          = $em;
+        $this->entityClass = $entityClass;
+    }
+
+    /**
+     * Retrieves associated EntityManager.
+     *
+     * @return \Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->em;
+    }
+
+    /**
+     * Name of the entity class that is cleared, or empty if all are cleared.
+     *
+     * @return string|null
+     */
+    public function getEntityClass()
+    {
+        return $this->entityClass;
+    }
+
+    /**
+     * Checks if event clears all entities.
+     *
+     * @return bool
+     */
+    public function clearsAllEntities()
+    {
+        return ($this->entityClass === null);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/OnFlushEventArgs.php

@@ -0,0 +1,61 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Common\EventArgs;
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Provides event arguments for the preFlush event.
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.org
+ * @since       2.0
+ * @author      Roman Borschel <roman@code-factory.de>
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class OnFlushEventArgs extends EventArgs
+{
+    /**
+     * @var EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * Constructor.
+     *
+     * @param EntityManagerInterface $em
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em = $em;
+    }
+
+    /**
+     * Retrieve associated EntityManager.
+     *
+     * @return \Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->em;
+    }
+
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/PostFlushEventArgs.php

@@ -0,0 +1,58 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Common\EventArgs;
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Provides event arguments for the postFlush event.
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.org
+ * @since       2.0
+ * @author      Daniel Freudenberger <df@rebuy.de>
+ */
+class PostFlushEventArgs extends EventArgs
+{
+    /**
+     * @var \Doctrine\ORM\EntityManager
+     */
+    private $em;
+
+    /**
+     * Constructor.
+     *
+     * @param EntityManagerInterface $em
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em = $em;
+    }
+
+    /**
+     * Retrieves associated EntityManager.
+     *
+     * @return \Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->em;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/PreFlushEventArgs.php

@@ -0,0 +1,58 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\Common\EventArgs;
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Provides event arguments for the preFlush event.
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.com
+ * @since       2.0
+ * @author      Roman Borschel <roman@code-factory.de>
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class PreFlushEventArgs extends EventArgs
+{
+    /**
+     * @var \Doctrine\ORM\EntityManager
+     */
+    private $em;
+
+    /**
+     * Constructor.
+     *
+     * @param EntityManagerInterface $em
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em = $em;
+    }
+
+    /**
+     * @return \Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->em;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Event/PreUpdateEventArgs.php

@@ -0,0 +1,137 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Class that holds event arguments for a preInsert/preUpdate event.
+ *
+ * @author Guilherme Blanco <guilehrmeblanco@hotmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @since  2.0
+ */
+class PreUpdateEventArgs extends LifecycleEventArgs
+{
+    /**
+     * @var array
+     */
+    private $entityChangeSet;
+
+    /**
+     * Constructor.
+     *
+     * @param object                 $entity
+     * @param EntityManagerInterface $em
+     * @param array                  $changeSet
+     */
+    public function __construct($entity, EntityManagerInterface $em, array &$changeSet)
+    {
+        parent::__construct($entity, $em);
+
+        $this->entityChangeSet = &$changeSet;
+    }
+
+    /**
+     * Retrieves entity changeset.
+     *
+     * @return array
+     */
+    public function getEntityChangeSet()
+    {
+        return $this->entityChangeSet;
+    }
+
+    /**
+     * Checks if field has a changeset.
+     *
+     * @param string $field
+     *
+     * @return boolean
+     */
+    public function hasChangedField($field)
+    {
+        return isset($this->entityChangeSet[$field]);
+    }
+
+    /**
+     * Gets the old value of the changeset of the changed field.
+     *
+     * @param string $field
+     *
+     * @return mixed
+     */
+    public function getOldValue($field)
+    {
+        $this->assertValidField($field);
+
+        return $this->entityChangeSet[$field][0];
+    }
+
+    /**
+     * Gets the new value of the changeset of the changed field.
+     *
+     * @param string $field
+     *
+     * @return mixed
+     */
+    public function getNewValue($field)
+    {
+        $this->assertValidField($field);
+
+        return $this->entityChangeSet[$field][1];
+    }
+
+    /**
+     * Sets the new value of this field.
+     *
+     * @param string $field
+     * @param mixed  $value
+     *
+     * @return void
+     */
+    public function setNewValue($field, $value)
+    {
+        $this->assertValidField($field);
+
+        $this->entityChangeSet[$field][1] = $value;
+    }
+
+    /**
+     * Asserts the field exists in changeset.
+     *
+     * @param string $field
+     *
+     * @return void
+     *
+     * @throws \InvalidArgumentException
+     */
+    private function assertValidField($field)
+    {
+        if ( ! isset($this->entityChangeSet[$field])) {
+            throw new \InvalidArgumentException(sprintf(
+                'Field "%s" is not a valid field of the entity "%s" in PreUpdateEventArgs.',
+                $field,
+                get_class($this->getEntity())
+            ));
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Events.php

@@ -0,0 +1,167 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+/**
+ * Container for all ORM events.
+ *
+ * This class cannot be instantiated.
+ *
+ * @author Roman Borschel <roman@code-factory.org>
+ * @since 2.0
+ */
+final class Events
+{
+    /**
+     * Private constructor. This class is not meant to be instantiated.
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * The preRemove event occurs for a given entity before the respective
+     * EntityManager remove operation for that entity is executed.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const preRemove = 'preRemove';
+
+    /**
+     * The postRemove event occurs for an entity after the entity has
+     * been deleted. It will be invoked after the database delete operations.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const postRemove = 'postRemove';
+
+    /**
+     * The prePersist event occurs for a given entity before the respective
+     * EntityManager persist operation for that entity is executed.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const prePersist = 'prePersist';
+
+    /**
+     * The postPersist event occurs for an entity after the entity has
+     * been made persistent. It will be invoked after the database insert operations.
+     * Generated primary key values are available in the postPersist event.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const postPersist = 'postPersist';
+
+    /**
+     * The preUpdate event occurs before the database update operations to
+     * entity data.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const preUpdate = 'preUpdate';
+
+    /**
+     * The postUpdate event occurs after the database update operations to
+     * entity data.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const postUpdate = 'postUpdate';
+
+    /**
+     * The postLoad event occurs for an entity after the entity has been loaded
+     * into the current EntityManager from the database or after the refresh operation
+     * has been applied to it.
+     *
+     * Note that the postLoad event occurs for an entity before any associations have been
+     * initialized. Therefore it is not safe to access associations in a postLoad callback
+     * or event handler.
+     *
+     * This is an entity lifecycle event.
+     *
+     * @var string
+     */
+    const postLoad = 'postLoad';
+
+    /**
+     * The loadClassMetadata event occurs after the mapping metadata for a class
+     * has been loaded from a mapping source (annotations/xml/yaml).
+     *
+     * @var string
+     */
+    const loadClassMetadata = 'loadClassMetadata';
+
+    /**
+     * The onClassMetadataNotFound event occurs whenever loading metadata for a class
+     * failed.
+     *
+     * @var string
+     */
+    const onClassMetadataNotFound = 'onClassMetadataNotFound';
+
+    /**
+     * The preFlush event occurs when the EntityManager#flush() operation is invoked,
+     * but before any changes to managed entities have been calculated. This event is
+     * always raised right after EntityManager#flush() call.
+     */
+    const preFlush = 'preFlush';
+
+    /**
+     * The onFlush event occurs when the EntityManager#flush() operation is invoked,
+     * after any changes to managed entities have been determined but before any
+     * actual database operations are executed. The event is only raised if there is
+     * actually something to do for the underlying UnitOfWork. If nothing needs to be done,
+     * the onFlush event is not raised.
+     *
+     * @var string
+     */
+    const onFlush = 'onFlush';
+
+    /**
+     * The postFlush event occurs when the EntityManager#flush() operation is invoked and
+     * after all actual database operations are executed successfully. The event is only raised if there is
+     * actually something to do for the underlying UnitOfWork. If nothing needs to be done,
+     * the postFlush event is not raised. The event won't be raised if an error occurs during the
+     * flush operation.
+     *
+     * @var string
+     */
+    const postFlush = 'postFlush';
+
+    /**
+     * The onClear event occurs when the EntityManager#clear() operation is invoked,
+     * after all references to entities have been removed from the unit of work.
+     *
+     * @var string
+     */
+    const onClear = 'onClear';
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Id/AbstractIdGenerator.php

@@ -0,0 +1,49 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+
+abstract class AbstractIdGenerator
+{
+    /**
+     * Generates an identifier for an entity.
+     *
+     * @param EntityManager $em
+     * @param object|null $entity
+     * @return mixed
+     */
+    abstract public function generate(EntityManager $em, $entity);
+
+    /**
+     * Gets whether this generator is a post-insert generator which means that
+     * {@link generate()} must be called after the entity has been inserted
+     * into the database.
+     *
+     * By default, this method returns FALSE. Generators that have this requirement
+     * must override this method and return TRUE.
+     *
+     * @return bool
+     */
+    public function isPostInsertGenerator()
+    {
+        return false;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Id/AssignedGenerator.php

@@ -0,0 +1,66 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\ORMException;
+
+/**
+ * Special generator for application-assigned identifiers (doesn't really generate anything).
+ *
+ * @since   2.0
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author  Jonathan Wage <jonwage@gmail.com>
+ * @author  Roman Borschel <roman@code-factory.org>
+ */
+class AssignedGenerator extends AbstractIdGenerator
+{
+    /**
+     * Returns the identifier assigned to the given entity.
+     *
+     * {@inheritDoc}
+     *
+     * @throws \Doctrine\ORM\ORMException
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        $class      = $em->getClassMetadata(get_class($entity));
+        $idFields   = $class->getIdentifierFieldNames();
+        $identifier = [];
+
+        foreach ($idFields as $idField) {
+            $value = $class->getFieldValue($entity, $idField);
+
+            if ( ! isset($value)) {
+                throw ORMException::entityMissingAssignedIdForField($entity, $idField);
+            }
+
+            if (isset($class->associationMappings[$idField])) {
+                // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
+                $value = $em->getUnitOfWork()->getSingleIdentifierValue($value);
+            }
+
+            $identifier[$idField] = $value;
+        }
+
+        return $identifier;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Id/BigIntegerIdentityGenerator.php

@@ -0,0 +1,66 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+
+/**
+ * Id generator that obtains IDs from special "identity" columns. These are columns
+ * that automatically get a database-generated, auto-incremented identifier on INSERT.
+ * This generator obtains the last insert id after such an insert.
+ */
+class BigIntegerIdentityGenerator extends AbstractIdGenerator
+{
+    /**
+     * The name of the sequence to pass to lastInsertId(), if any.
+     *
+     * @var string
+     */
+    private $sequenceName;
+
+    /**
+     * Constructor.
+     *
+     * @param string|null $sequenceName The name of the sequence to pass to lastInsertId()
+     *                                  to obtain the last generated identifier within the current
+     *                                  database session/connection, if any.
+     */
+    public function __construct($sequenceName = null)
+    {
+        $this->sequenceName = $sequenceName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        return (string) $em->getConnection()->lastInsertId($this->sequenceName);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isPostInsertGenerator()
+    {
+        return true;
+    }
+}
+

vendor/doctrine/orm/lib/Doctrine/ORM/Id/IdentityGenerator.php

@@ -0,0 +1,65 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+
+/**
+ * Id generator that obtains IDs from special "identity" columns. These are columns
+ * that automatically get a database-generated, auto-incremented identifier on INSERT.
+ * This generator obtains the last insert id after such an insert.
+ */
+class IdentityGenerator extends AbstractIdGenerator
+{
+    /**
+     * The name of the sequence to pass to lastInsertId(), if any.
+     *
+     * @var string
+     */
+    private $sequenceName;
+
+    /**
+     * Constructor.
+     *
+     * @param string|null $sequenceName The name of the sequence to pass to lastInsertId()
+     *                                  to obtain the last generated identifier within the current
+     *                                  database session/connection, if any.
+     */
+    public function __construct($sequenceName = null)
+    {
+        $this->sequenceName = $sequenceName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        return (int) $em->getConnection()->lastInsertId($this->sequenceName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isPostInsertGenerator()
+    {
+        return true;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Id/SequenceGenerator.php

@@ -0,0 +1,132 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+use Serializable;
+
+/**
+ * Represents an ID generator that uses a database sequence.
+ *
+ * @since 2.0
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class SequenceGenerator extends AbstractIdGenerator implements Serializable
+{
+    /**
+     * The allocation size of the sequence.
+     *
+     * @var int
+     */
+    private $_allocationSize;
+
+    /**
+     * The name of the sequence.
+     *
+     * @var string
+     */
+    private $_sequenceName;
+
+    /**
+     * @var int
+     */
+    private $_nextValue = 0;
+
+    /**
+     * @var int|null
+     */
+    private $_maxValue = null;
+
+    /**
+     * Initializes a new sequence generator.
+     *
+     * @param string  $sequenceName   The name of the sequence.
+     * @param integer $allocationSize The allocation size of the sequence.
+     */
+    public function __construct($sequenceName, $allocationSize)
+    {
+        $this->_sequenceName = $sequenceName;
+        $this->_allocationSize = $allocationSize;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        if ($this->_maxValue === null || $this->_nextValue == $this->_maxValue) {
+            // Allocate new values
+            $conn = $em->getConnection();
+            $sql  = $conn->getDatabasePlatform()->getSequenceNextValSQL($this->_sequenceName);
+
+            // Using `query` to force usage of the master server in MasterSlaveConnection
+            $this->_nextValue = (int) $conn->query($sql)->fetchColumn();
+            $this->_maxValue  = $this->_nextValue + $this->_allocationSize;
+        }
+
+        return $this->_nextValue++;
+    }
+
+    /**
+     * Gets the maximum value of the currently allocated bag of values.
+     *
+     * @return integer|null
+     */
+    public function getCurrentMaxValue()
+    {
+        return $this->_maxValue;
+    }
+
+    /**
+     * Gets the next value that will be returned by generate().
+     *
+     * @return integer
+     */
+    public function getNextValue()
+    {
+        return $this->_nextValue;
+    }
+
+    /**
+     * @return string
+     */
+    public function serialize()
+    {
+        return serialize(
+            [
+            'allocationSize' => $this->_allocationSize,
+            'sequenceName'   => $this->_sequenceName
+            ]
+        );
+    }
+
+    /**
+     * @param string $serialized
+     *
+     * @return void
+     */
+    public function unserialize($serialized)
+    {
+        $array = unserialize($serialized);
+
+        $this->_sequenceName = $array['sequenceName'];
+        $this->_allocationSize = $array['allocationSize'];
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Id/TableGenerator.php

@@ -0,0 +1,109 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+
+/**
+ * Id generator that uses a single-row database table and a hi/lo algorithm.
+ *
+ * @since   2.0
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author  Jonathan Wage <jonwage@gmail.com>
+ * @author  Roman Borschel <roman@code-factory.org>
+ */
+class TableGenerator extends AbstractIdGenerator
+{
+    /**
+     * @var string
+     */
+    private $_tableName;
+
+    /**
+     * @var string
+     */
+    private $_sequenceName;
+
+    /**
+     * @var int
+     */
+    private $_allocationSize;
+
+    /**
+     * @var int|null
+     */
+    private $_nextValue;
+
+    /**
+     * @var int|null
+     */
+    private $_maxValue;
+
+    /**
+     * @param string $tableName
+     * @param string $sequenceName
+     * @param int    $allocationSize
+     */
+    public function __construct($tableName, $sequenceName = 'default', $allocationSize = 10)
+    {
+        $this->_tableName = $tableName;
+        $this->_sequenceName = $sequenceName;
+        $this->_allocationSize = $allocationSize;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function generate(
+        EntityManager $em, $entity)
+    {
+        if ($this->_maxValue === null || $this->_nextValue == $this->_maxValue) {
+            // Allocate new values
+            $conn = $em->getConnection();
+
+            if ($conn->getTransactionNestingLevel() === 0) {
+                // use select for update
+                $sql          = $conn->getDatabasePlatform()->getTableHiLoCurrentValSql($this->_tableName, $this->_sequenceName);
+                $currentLevel = $conn->fetchColumn($sql);
+
+                if ($currentLevel != null) {
+                    $this->_nextValue = $currentLevel;
+                    $this->_maxValue = $this->_nextValue + $this->_allocationSize;
+
+                    $updateSql = $conn->getDatabasePlatform()->getTableHiLoUpdateNextValSql(
+                        $this->_tableName, $this->_sequenceName, $this->_allocationSize
+                    );
+
+                    if ($conn->executeUpdate($updateSql, [1 => $currentLevel, 2 => $currentLevel+1]) !== 1) {
+                        // no affected rows, concurrency issue, throw exception
+                    }
+                } else {
+                    // no current level returned, TableGenerator seems to be broken, throw exception
+                }
+            } else {
+                // only table locks help here, implement this or throw exception?
+                // or do we want to work with table locks exclusively?
+            }
+        }
+
+        return $this->_nextValue++;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Id/UuidGenerator.php

@@ -0,0 +1,42 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+
+/**
+ * Represents an ID generator that uses the database UUID expression
+ *
+ * @since 2.3
+ * @author Maarten de Keizer <m.de.keizer@markei.nl>
+ */
+class UuidGenerator extends AbstractIdGenerator
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        $conn = $em->getConnection();
+        $sql = 'SELECT ' . $conn->getDatabasePlatform()->getGuidExpression();
+
+        return $conn->query($sql)->fetchColumn(0);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php

@@ -0,0 +1,195 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal;
+
+/**
+ * CommitOrderCalculator implements topological sorting, which is an ordering
+ * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
+ * using a depth-first searching (DFS) to traverse the graph built in memory.
+ * This algorithm have a linear running time based on nodes (V) and dependency
+ * between the nodes (E), resulting in a computational complexity of O(V + E).
+ *
+ * @since  2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class CommitOrderCalculator
+{
+    const NOT_VISITED = 0;
+    const IN_PROGRESS = 1;
+    const VISITED     = 2;
+
+    /**
+     * Matrix of nodes (aka. vertex).
+     * Keys are provided hashes and values are the node definition objects.
+     *
+     * The node state definition contains the following properties:
+     *
+     * - <b>state</b> (integer)
+     * Whether the node is NOT_VISITED or IN_PROGRESS
+     *
+     * - <b>value</b> (object)
+     * Actual node value
+     *
+     * - <b>dependencyList</b> (array<string>)
+     * Map of node dependencies defined as hashes.
+     *
+     * @var array<\stdClass>
+     */
+    private $nodeList = [];
+
+    /**
+     * Volatile variable holding calculated nodes during sorting process.
+     *
+     * @var array
+     */
+    private $sortedNodeList = [];
+
+    /**
+     * Checks for node (vertex) existence in graph.
+     *
+     * @param string $hash
+     *
+     * @return boolean
+     */
+    public function hasNode($hash)
+    {
+        return isset($this->nodeList[$hash]);
+    }
+
+    /**
+     * Adds a new node (vertex) to the graph, assigning its hash and value.
+     *
+     * @param string $hash
+     * @param object $node
+     *
+     * @return void
+     */
+    public function addNode($hash, $node)
+    {
+        $vertex = new \stdClass();
+
+        $vertex->hash           = $hash;
+        $vertex->state          = self::NOT_VISITED;
+        $vertex->value          = $node;
+        $vertex->dependencyList = [];
+
+        $this->nodeList[$hash] = $vertex;
+    }
+
+    /**
+     * Adds a new dependency (edge) to the graph using their hashes.
+     *
+     * @param string  $fromHash
+     * @param string  $toHash
+     * @param integer $weight
+     *
+     * @return void
+     */
+    public function addDependency($fromHash, $toHash, $weight)
+    {
+        $vertex = $this->nodeList[$fromHash];
+        $edge   = new \stdClass();
+
+        $edge->from   = $fromHash;
+        $edge->to     = $toHash;
+        $edge->weight = $weight;
+
+        $vertex->dependencyList[$toHash] = $edge;
+    }
+
+    /**
+     * Return a valid order list of all current nodes.
+     * The desired topological sorting is the reverse post order of these searches.
+     *
+     * {@internal Highly performance-sensitive method.}
+     *
+     * @return array
+     */
+    public function sort()
+    {
+        foreach ($this->nodeList as $vertex) {
+            if ($vertex->state !== self::NOT_VISITED) {
+                continue;
+            }
+
+            $this->visit($vertex);
+        }
+
+        $sortedList = $this->sortedNodeList;
+
+        $this->nodeList       = [];
+        $this->sortedNodeList = [];
+
+        return array_reverse($sortedList);
+    }
+
+    /**
+     * Visit a given node definition for reordering.
+     *
+     * {@internal Highly performance-sensitive method.}
+     *
+     * @param \stdClass $vertex
+     */
+    private function visit($vertex)
+    {
+        $vertex->state = self::IN_PROGRESS;
+
+        foreach ($vertex->dependencyList as $edge) {
+            $adjacentVertex = $this->nodeList[$edge->to];
+
+            switch ($adjacentVertex->state) {
+                case self::VISITED:
+                    // Do nothing, since node was already visited
+                    break;
+
+                case self::IN_PROGRESS:
+                    if (isset($adjacentVertex->dependencyList[$vertex->hash]) &&
+                        $adjacentVertex->dependencyList[$vertex->hash]->weight < $edge->weight) {
+
+                        // If we have some non-visited dependencies in the in-progress dependency, we
+                        // need to visit them before adding the node.
+                        foreach ($adjacentVertex->dependencyList as $adjacentEdge) {
+                            $adjacentEdgeVertex = $this->nodeList[$adjacentEdge->to];
+
+                            if ($adjacentEdgeVertex->state === self::NOT_VISITED) {
+                                $this->visit($adjacentEdgeVertex);
+                            }
+                        }
+
+                        $adjacentVertex->state = self::VISITED;
+
+                        $this->sortedNodeList[] = $adjacentVertex->value;
+                    }
+                    break;
+
+                case self::NOT_VISITED:
+                    $this->visit($adjacentVertex);
+            }
+        }
+
+        if ($vertex->state !== self::VISITED) {
+            $vertex->state = self::VISITED;
+
+            $this->sortedNodeList[] = $vertex->value;
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php

@@ -0,0 +1,538 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Tools\Pagination\LimitSubqueryWalker;
+use PDO;
+use function array_map;
+use function in_array;
+
+/**
+ * Base class for all hydrators. A hydrator is a class that provides some form
+ * of transformation of an SQL result set into another structure.
+ *
+ * @since  2.0
+ * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
+ */
+abstract class AbstractHydrator
+{
+    /**
+     * The ResultSetMapping.
+     *
+     * @var \Doctrine\ORM\Query\ResultSetMapping
+     */
+    protected $_rsm;
+
+    /**
+     * The EntityManager instance.
+     *
+     * @var EntityManagerInterface
+     */
+    protected $_em;
+
+    /**
+     * The dbms Platform instance.
+     *
+     * @var \Doctrine\DBAL\Platforms\AbstractPlatform
+     */
+    protected $_platform;
+
+    /**
+     * The UnitOfWork of the associated EntityManager.
+     *
+     * @var \Doctrine\ORM\UnitOfWork
+     */
+    protected $_uow;
+
+    /**
+     * Local ClassMetadata cache to avoid going to the EntityManager all the time.
+     *
+     * @var array
+     */
+    protected $_metadataCache = [];
+
+    /**
+     * The cache used during row-by-row hydration.
+     *
+     * @var array
+     */
+    protected $_cache = [];
+
+    /**
+     * The statement that provides the data to hydrate.
+     *
+     * @var \Doctrine\DBAL\Driver\Statement
+     */
+    protected $_stmt;
+
+    /**
+     * The query hints.
+     *
+     * @var array
+     */
+    protected $_hints;
+
+    /**
+     * Initializes a new instance of a class derived from <tt>AbstractHydrator</tt>.
+     *
+     * @param EntityManagerInterface $em The EntityManager to use.
+     */
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->_em       = $em;
+        $this->_platform = $em->getConnection()->getDatabasePlatform();
+        $this->_uow      = $em->getUnitOfWork();
+    }
+
+    /**
+     * Initiates a row-by-row hydration.
+     *
+     * @param object $stmt
+     * @param object $resultSetMapping
+     * @param array  $hints
+     *
+     * @return IterableResult
+     */
+    public function iterate($stmt, $resultSetMapping, array $hints = [])
+    {
+        $this->_stmt  = $stmt;
+        $this->_rsm   = $resultSetMapping;
+        $this->_hints = $hints;
+
+        $evm = $this->_em->getEventManager();
+
+        $evm->addEventListener([Events::onClear], $this);
+
+        $this->prepare();
+
+        return new IterableResult($this);
+    }
+
+    /**
+     * Hydrates all rows returned by the passed statement instance at once.
+     *
+     * @param object $stmt
+     * @param object $resultSetMapping
+     * @param array  $hints
+     *
+     * @return array
+     */
+    public function hydrateAll($stmt, $resultSetMapping, array $hints = [])
+    {
+        $this->_stmt  = $stmt;
+        $this->_rsm   = $resultSetMapping;
+        $this->_hints = $hints;
+
+        $this->_em->getEventManager()->addEventListener([Events::onClear], $this);
+
+        $this->prepare();
+
+        $result = $this->hydrateAllData();
+
+        $this->cleanup();
+
+        return $result;
+    }
+
+    /**
+     * Hydrates a single row returned by the current statement instance during
+     * row-by-row hydration with {@link iterate()}.
+     *
+     * @return mixed
+     */
+    public function hydrateRow()
+    {
+        $row = $this->_stmt->fetch(PDO::FETCH_ASSOC);
+
+        if ( ! $row) {
+            $this->cleanup();
+
+            return false;
+        }
+
+        $result = [];
+
+        $this->hydrateRowData($row, $result);
+
+        return $result;
+    }
+
+    /**
+     * When executed in a hydrate() loop we have to clear internal state to
+     * decrease memory consumption.
+     *
+     * @param mixed $eventArgs
+     *
+     * @return void
+     */
+    public function onClear($eventArgs)
+    {
+    }
+
+    /**
+     * Executes one-time preparation tasks, once each time hydration is started
+     * through {@link hydrateAll} or {@link iterate()}.
+     *
+     * @return void
+     */
+    protected function prepare()
+    {
+    }
+
+    /**
+     * Executes one-time cleanup tasks at the end of a hydration that was initiated
+     * through {@link hydrateAll} or {@link iterate()}.
+     *
+     * @return void
+     */
+    protected function cleanup()
+    {
+        $this->_stmt->closeCursor();
+
+        $this->_stmt          = null;
+        $this->_rsm           = null;
+        $this->_cache         = [];
+        $this->_metadataCache = [];
+
+        $this
+            ->_em
+            ->getEventManager()
+            ->removeEventListener([Events::onClear], $this);
+    }
+
+    /**
+     * Hydrates a single row from the current statement instance.
+     *
+     * Template method.
+     *
+     * @param mixed[] $row    The row data.
+     * @param mixed[] $result The result to fill.
+     *
+     * @return void
+     *
+     * @throws HydrationException
+     */
+    protected function hydrateRowData(array $row, array &$result)
+    {
+        throw new HydrationException("hydrateRowData() not implemented by this hydrator.");
+    }
+
+    /**
+     * Hydrates all rows from the current statement instance at once.
+     *
+     * @return array
+     */
+    abstract protected function hydrateAllData();
+
+    /**
+     * Processes a row of the result set.
+     *
+     * Used for identity-based hydration (HYDRATE_OBJECT and HYDRATE_ARRAY).
+     * Puts the elements of a result row into a new array, grouped by the dql alias
+     * they belong to. The column names in the result set are mapped to their
+     * field names during this procedure as well as any necessary conversions on
+     * the values applied. Scalar values are kept in a specific key 'scalars'.
+     *
+     * @param array  $data               SQL Result Row.
+     * @param array &$id                 Dql-Alias => ID-Hash.
+     * @param array &$nonemptyComponents Does this DQL-Alias has at least one non NULL value?
+     *
+     * @return array<string, array<string, mixed>> An array with all the fields
+     *                                             (name => value) of the data
+     *                                             row, grouped by their
+     *                                             component alias.
+     *
+     * @psalm-return array{
+     *                   data: array<array-key, array>,
+     *                   newObjects?: array<array-key, array{
+     *                       class: mixed,
+     *                       args?: array
+     *                   }>,
+     *                   scalars?: array
+     *               }
+     */
+    protected function gatherRowData(array $data, array &$id, array &$nonemptyComponents)
+    {
+        $rowData = ['data' => []];
+
+        foreach ($data as $key => $value) {
+            if (($cacheKeyInfo = $this->hydrateColumnInfo($key)) === null) {
+                continue;
+            }
+
+            $fieldName = $cacheKeyInfo['fieldName'];
+
+            switch (true) {
+                case (isset($cacheKeyInfo['isNewObjectParameter'])):
+                    $argIndex = $cacheKeyInfo['argIndex'];
+                    $objIndex = $cacheKeyInfo['objIndex'];
+                    $type     = $cacheKeyInfo['type'];
+                    $value    = $type->convertToPHPValue($value, $this->_platform);
+
+                    $rowData['newObjects'][$objIndex]['class']           = $cacheKeyInfo['class'];
+                    $rowData['newObjects'][$objIndex]['args'][$argIndex] = $value;
+                    break;
+
+                case (isset($cacheKeyInfo['isScalar'])):
+                    $type  = $cacheKeyInfo['type'];
+                    $value = $type->convertToPHPValue($value, $this->_platform);
+
+                    $rowData['scalars'][$fieldName] = $value;
+                    break;
+
+                //case (isset($cacheKeyInfo['isMetaColumn'])):
+                default:
+                    $dqlAlias = $cacheKeyInfo['dqlAlias'];
+                    $type     = $cacheKeyInfo['type'];
+
+                    // If there are field name collisions in the child class, then we need
+                    // to only hydrate if we are looking at the correct discriminator value
+                    if (isset($cacheKeyInfo['discriminatorColumn'], $data[$cacheKeyInfo['discriminatorColumn']])
+                        && ! in_array((string) $data[$cacheKeyInfo['discriminatorColumn']], $cacheKeyInfo['discriminatorValues'], true)
+                    ) {
+                        break;
+                    }
+
+                    // in an inheritance hierarchy the same field could be defined several times.
+                    // We overwrite this value so long we don't have a non-null value, that value we keep.
+                    // Per definition it cannot be that a field is defined several times and has several values.
+                    if (isset($rowData['data'][$dqlAlias][$fieldName])) {
+                        break;
+                    }
+
+                    $rowData['data'][$dqlAlias][$fieldName] = $type
+                        ? $type->convertToPHPValue($value, $this->_platform)
+                        : $value;
+
+                    if ($cacheKeyInfo['isIdentifier'] && $value !== null) {
+                        $id[$dqlAlias] .= '|' . $value;
+                        $nonemptyComponents[$dqlAlias] = true;
+                    }
+                    break;
+            }
+        }
+
+        return $rowData;
+    }
+
+    /**
+     * Processes a row of the result set.
+     *
+     * Used for HYDRATE_SCALAR. This is a variant of _gatherRowData() that
+     * simply converts column names to field names and properly converts the
+     * values according to their types. The resulting row has the same number
+     * of elements as before.
+     *
+     * @param array $data
+     *
+     * @return array The processed row.
+     */
+    protected function gatherScalarRowData(&$data)
+    {
+        $rowData = [];
+
+        foreach ($data as $key => $value) {
+            if (($cacheKeyInfo = $this->hydrateColumnInfo($key)) === null) {
+                continue;
+            }
+
+            $fieldName = $cacheKeyInfo['fieldName'];
+
+            // WARNING: BC break! We know this is the desired behavior to type convert values, but this
+            // erroneous behavior exists since 2.0 and we're forced to keep compatibility.
+            if (! isset($cacheKeyInfo['isScalar'])) {
+                $type  = $cacheKeyInfo['type'];
+                $value = $type ? $type->convertToPHPValue($value, $this->_platform) : $value;
+
+                $fieldName = $cacheKeyInfo['dqlAlias'] . '_' . $fieldName;
+            }
+
+            $rowData[$fieldName] = $value;
+        }
+
+        return $rowData;
+    }
+
+    /**
+     * Retrieve column information from ResultSetMapping.
+     *
+     * @param string $key Column name
+     *
+     * @return array|null
+     */
+    protected function hydrateColumnInfo($key)
+    {
+        if (isset($this->_cache[$key])) {
+            return $this->_cache[$key];
+        }
+
+        switch (true) {
+            // NOTE: Most of the times it's a field mapping, so keep it first!!!
+            case (isset($this->_rsm->fieldMappings[$key])):
+                $classMetadata = $this->getClassMetadata($this->_rsm->declaringClasses[$key]);
+                $fieldName     = $this->_rsm->fieldMappings[$key];
+                $fieldMapping  = $classMetadata->fieldMappings[$fieldName];
+                $ownerMap      = $this->_rsm->columnOwnerMap[$key];
+                $columnInfo    = [
+                    'isIdentifier' => \in_array($fieldName, $classMetadata->identifier, true),
+                    'fieldName'    => $fieldName,
+                    'type'         => Type::getType($fieldMapping['type']),
+                    'dqlAlias'     => $ownerMap,
+                ];
+
+                // the current discriminator value must be saved in order to disambiguate fields hydration,
+                // should there be field name collisions
+                if ($classMetadata->parentClasses && isset($this->_rsm->discriminatorColumns[$ownerMap])) {
+                    return $this->_cache[$key] = \array_merge(
+                        $columnInfo,
+                        [
+                            'discriminatorColumn' => $this->_rsm->discriminatorColumns[$ownerMap],
+                            'discriminatorValue'  => $classMetadata->discriminatorValue,
+                            'discriminatorValues' => $this->getDiscriminatorValues($classMetadata),
+                        ]
+                    );
+                }
+
+                return $this->_cache[$key] = $columnInfo;
+
+            case (isset($this->_rsm->newObjectMappings[$key])):
+                // WARNING: A NEW object is also a scalar, so it must be declared before!
+                $mapping = $this->_rsm->newObjectMappings[$key];
+
+                return $this->_cache[$key] = [
+                    'isScalar'             => true,
+                    'isNewObjectParameter' => true,
+                    'fieldName'            => $this->_rsm->scalarMappings[$key],
+                    'type'                 => Type::getType($this->_rsm->typeMappings[$key]),
+                    'argIndex'             => $mapping['argIndex'],
+                    'objIndex'             => $mapping['objIndex'],
+                    'class'                => new \ReflectionClass($mapping['className']),
+                ];
+
+            case isset($this->_rsm->scalarMappings[$key], $this->_hints[LimitSubqueryWalker::FORCE_DBAL_TYPE_CONVERSION]):
+                return $this->_cache[$key] = [
+                    'fieldName' => $this->_rsm->scalarMappings[$key],
+                    'type'      => Type::getType($this->_rsm->typeMappings[$key]),
+                    'dqlAlias'  => '',
+                ];
+            case (isset($this->_rsm->scalarMappings[$key])):
+                return $this->_cache[$key] = [
+                    'isScalar'  => true,
+                    'fieldName' => $this->_rsm->scalarMappings[$key],
+                    'type'      => Type::getType($this->_rsm->typeMappings[$key]),
+                ];
+
+            case (isset($this->_rsm->metaMappings[$key])):
+                // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
+                $fieldName = $this->_rsm->metaMappings[$key];
+                $dqlAlias  = $this->_rsm->columnOwnerMap[$key];
+                $type      = isset($this->_rsm->typeMappings[$key])
+                    ? Type::getType($this->_rsm->typeMappings[$key])
+                    : null;
+
+                // Cache metadata fetch
+                $this->getClassMetadata($this->_rsm->aliasMap[$dqlAlias]);
+
+                return $this->_cache[$key] = [
+                    'isIdentifier' => isset($this->_rsm->isIdentifierColumn[$dqlAlias][$key]),
+                    'isMetaColumn' => true,
+                    'fieldName'    => $fieldName,
+                    'type'         => $type,
+                    'dqlAlias'     => $dqlAlias,
+                ];
+        }
+
+        // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
+        // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
+        return null;
+    }
+
+    /**
+     * @return string[]
+     */
+    private function getDiscriminatorValues(ClassMetadata $classMetadata) : array
+    {
+        $values = array_map(
+            function (string $subClass) : string {
+                return (string) $this->getClassMetadata($subClass)->discriminatorValue;
+            },
+            $classMetadata->subClasses
+        );
+
+        $values[] = (string) $classMetadata->discriminatorValue;
+
+        return $values;
+    }
+
+    /**
+     * Retrieve ClassMetadata associated to entity class name.
+     *
+     * @param string $className
+     *
+     * @return \Doctrine\ORM\Mapping\ClassMetadata
+     */
+    protected function getClassMetadata($className)
+    {
+        if ( ! isset($this->_metadataCache[$className])) {
+            $this->_metadataCache[$className] = $this->_em->getClassMetadata($className);
+        }
+
+        return $this->_metadataCache[$className];
+    }
+
+    /**
+     * Register entity as managed in UnitOfWork.
+     *
+     * @param ClassMetadata $class
+     * @param object        $entity
+     * @param array         $data
+     *
+     * @return void
+     *
+     * @todo The "$id" generation is the same of UnitOfWork#createEntity. Remove this duplication somehow
+     */
+    protected function registerManaged(ClassMetadata $class, $entity, array $data)
+    {
+        if ($class->isIdentifierComposite) {
+            $id = [];
+
+            foreach ($class->identifier as $fieldName) {
+                $id[$fieldName] = isset($class->associationMappings[$fieldName])
+                    ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
+                    : $data[$fieldName];
+            }
+        } else {
+            $fieldName = $class->identifier[0];
+            $id        = [
+                $fieldName => isset($class->associationMappings[$fieldName])
+                    ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
+                    : $data[$fieldName]
+            ];
+        }
+
+        $this->_em->getUnitOfWork()->registerManaged($entity, $id, $data);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/ArrayHydrator.php

@@ -0,0 +1,307 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+use PDO;
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+/**
+ * The ArrayHydrator produces a nested array "graph" that is often (not always)
+ * interchangeable with the corresponding object graph for read-only access.
+ *
+ * @since  2.0
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
+ */
+class ArrayHydrator extends AbstractHydrator
+{
+    /**
+     * @var array
+     */
+    private $_rootAliases = [];
+
+    /**
+     * @var bool
+     */
+    private $_isSimpleQuery = false;
+
+    /**
+     * @var array
+     */
+    private $_identifierMap = [];
+
+    /**
+     * @var array
+     */
+    private $_resultPointers = [];
+
+    /**
+     * @var array
+     */
+    private $_idTemplate = [];
+
+    /**
+     * @var int
+     */
+    private $_resultCounter = 0;
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function prepare()
+    {
+        $this->_isSimpleQuery = count($this->_rsm->aliasMap) <= 1;
+
+        foreach ($this->_rsm->aliasMap as $dqlAlias => $className) {
+            $this->_identifierMap[$dqlAlias]  = [];
+            $this->_resultPointers[$dqlAlias] = [];
+            $this->_idTemplate[$dqlAlias]     = '';
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
+    {
+        $result = [];
+
+        while ($data = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
+            $this->hydrateRowData($data, $result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateRowData(array $row, array &$result)
+    {
+        // 1) Initialize
+        $id = $this->_idTemplate; // initialize the id-memory
+        $nonemptyComponents = [];
+        $rowData = $this->gatherRowData($row, $id, $nonemptyComponents);
+
+        // 2) Now hydrate the data found in the current row.
+        foreach ($rowData['data'] as $dqlAlias => $data) {
+            $index = false;
+
+            if (isset($this->_rsm->parentAliasMap[$dqlAlias])) {
+                // It's a joined result
+
+                $parent = $this->_rsm->parentAliasMap[$dqlAlias];
+                $path   = $parent . '.' . $dqlAlias;
+
+                // missing parent data, skipping as RIGHT JOIN hydration is not supported.
+                if ( ! isset($nonemptyComponents[$parent]) ) {
+                    continue;
+                }
+
+                // Get a reference to the right element in the result tree.
+                // This element will get the associated element attached.
+                if ($this->_rsm->isMixed && isset($this->_rootAliases[$parent])) {
+                    $first = reset($this->_resultPointers);
+                    // TODO: Exception if $key === null ?
+                    $baseElement =& $this->_resultPointers[$parent][key($first)];
+                } else if (isset($this->_resultPointers[$parent])) {
+                    $baseElement =& $this->_resultPointers[$parent];
+                } else {
+                    unset($this->_resultPointers[$dqlAlias]); // Ticket #1228
+
+                    continue;
+                }
+
+                $relationAlias = $this->_rsm->relationMap[$dqlAlias];
+                $parentClass   = $this->_metadataCache[$this->_rsm->aliasMap[$parent]];
+                $relation      = $parentClass->associationMappings[$relationAlias];
+
+                // Check the type of the relation (many or single-valued)
+                if ( ! ($relation['type'] & ClassMetadata::TO_ONE)) {
+                    $oneToOne = false;
+
+                    if ( ! isset($baseElement[$relationAlias])) {
+                        $baseElement[$relationAlias] = [];
+                    }
+
+                    if (isset($nonemptyComponents[$dqlAlias])) {
+                        $indexExists  = isset($this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]]);
+                        $index        = $indexExists ? $this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]] : false;
+                        $indexIsValid = $index !== false ? isset($baseElement[$relationAlias][$index]) : false;
+
+                        if ( ! $indexExists || ! $indexIsValid) {
+                            $element = $data;
+
+                            if (isset($this->_rsm->indexByMap[$dqlAlias])) {
+                                $baseElement[$relationAlias][$row[$this->_rsm->indexByMap[$dqlAlias]]] = $element;
+                            } else {
+                                $baseElement[$relationAlias][] = $element;
+                            }
+
+                            end($baseElement[$relationAlias]);
+
+                            $this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]] = key($baseElement[$relationAlias]);
+                        }
+                    }
+                } else {
+                    $oneToOne = true;
+
+                    if (
+                        ( ! isset($nonemptyComponents[$dqlAlias])) &&
+                        ( ! isset($baseElement[$relationAlias]))
+                    ) {
+                        $baseElement[$relationAlias] = null;
+                    } else if ( ! isset($baseElement[$relationAlias])) {
+                        $baseElement[$relationAlias] = $data;
+                    }
+                }
+
+                $coll =& $baseElement[$relationAlias];
+
+                if (is_array($coll)) {
+                    $this->updateResultPointer($coll, $index, $dqlAlias, $oneToOne);
+                }
+            } else {
+                // It's a root result element
+
+                $this->_rootAliases[$dqlAlias] = true; // Mark as root
+                $entityKey = $this->_rsm->entityMappings[$dqlAlias] ?: 0;
+
+                // if this row has a NULL value for the root result id then make it a null result.
+                if ( ! isset($nonemptyComponents[$dqlAlias]) ) {
+                    $result[] = $this->_rsm->isMixed
+                        ? [$entityKey => null]
+                        : null;
+
+                    $resultKey = $this->_resultCounter;
+                    ++$this->_resultCounter;
+
+                    continue;
+                }
+
+                // Check for an existing element
+                if ($this->_isSimpleQuery || ! isset($this->_identifierMap[$dqlAlias][$id[$dqlAlias]])) {
+                    $element = $this->_rsm->isMixed
+                        ? [$entityKey => $data]
+                        : $data;
+
+                    if (isset($this->_rsm->indexByMap[$dqlAlias])) {
+                        $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
+                        $result[$resultKey] = $element;
+                    } else {
+                        $resultKey = $this->_resultCounter;
+                        $result[] = $element;
+
+                        ++$this->_resultCounter;
+                    }
+
+                    $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = $resultKey;
+                } else {
+                    $index = $this->_identifierMap[$dqlAlias][$id[$dqlAlias]];
+                    $resultKey = $index;
+                }
+
+                $this->updateResultPointer($result, $index, $dqlAlias, false);
+            }
+        }
+
+        if ( ! isset($resultKey)) {
+            $this->_resultCounter++;
+        }
+
+        // Append scalar values to mixed result sets
+        if (isset($rowData['scalars'])) {
+            if ( ! isset($resultKey)) {
+                // this only ever happens when no object is fetched (scalar result only)
+                $resultKey = isset($this->_rsm->indexByMap['scalars'])
+                    ? $row[$this->_rsm->indexByMap['scalars']]
+                    : $this->_resultCounter - 1;
+            }
+
+            foreach ($rowData['scalars'] as $name => $value) {
+                $result[$resultKey][$name] = $value;
+            }
+        }
+
+        // Append new object to mixed result sets
+        if (isset($rowData['newObjects'])) {
+            if ( ! isset($resultKey)) {
+                $resultKey = $this->_resultCounter - 1;
+            }
+
+            $scalarCount = (isset($rowData['scalars'])? count($rowData['scalars']): 0);
+
+            foreach ($rowData['newObjects'] as $objIndex => $newObject) {
+                $class  = $newObject['class'];
+                $args   = $newObject['args'];
+                $obj    = $class->newInstanceArgs($args);
+
+                if (count($args) == $scalarCount || ($scalarCount == 0 && count($rowData['newObjects']) == 1)) {
+                    $result[$resultKey] = $obj;
+
+                    continue;
+                }
+
+                $result[$resultKey][$objIndex] = $obj;
+            }
+        }
+    }
+
+    /**
+     * Updates the result pointer for an Entity. The result pointers point to the
+     * last seen instance of each Entity type. This is used for graph construction.
+     *
+     * @param array           $coll     The element.
+     * @param boolean|integer $index    Index of the element in the collection.
+     * @param string          $dqlAlias
+     * @param boolean         $oneToOne Whether it is a single-valued association or not.
+     *
+     * @return void
+     */
+    private function updateResultPointer(array &$coll, $index, $dqlAlias, $oneToOne)
+    {
+        if ($coll === null) {
+            unset($this->_resultPointers[$dqlAlias]); // Ticket #1228
+
+            return;
+        }
+
+        if ($oneToOne) {
+            $this->_resultPointers[$dqlAlias] =& $coll;
+
+            return;
+        }
+
+        if ($index !== false) {
+            $this->_resultPointers[$dqlAlias] =& $coll[$index];
+
+            return;
+        }
+
+        if ( ! $coll) {
+            return;
+        }
+
+        end($coll);
+        $this->_resultPointers[$dqlAlias] =& $coll[key($coll)];
+
+        return;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/HydrationException.php

@@ -0,0 +1,105 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+class HydrationException extends \Doctrine\ORM\ORMException
+{
+    /**
+     * @return HydrationException
+     */
+    public static function nonUniqueResult()
+    {
+        return new self("The result returned by the query was not unique.");
+    }
+
+    /**
+     * @param string $alias
+     * @param string $parentAlias
+     *
+     * @return HydrationException
+     */
+    public static function parentObjectOfRelationNotFound($alias, $parentAlias)
+    {
+        return new self("The parent object of entity result with alias '$alias' was not found."
+            . " The parent alias is '$parentAlias'.");
+    }
+
+    /**
+     * @param string $dqlAlias
+     *
+     * @return HydrationException
+     */
+    public static function emptyDiscriminatorValue($dqlAlias)
+    {
+        return new self("The DQL alias '" . $dqlAlias . "' contains an entity ".
+            "of an inheritance hierarchy with an empty discriminator value. This means " .
+            "that the database contains inconsistent data with an empty " .
+            "discriminator value in a table row."
+        );
+    }
+
+    /**
+     * @since 2.3
+     *
+     * @param string $entityName
+     * @param string $discrColumnName
+     * @param string $dqlAlias
+     *
+     * @return HydrationException
+     */
+    public static function missingDiscriminatorColumn($entityName, $discrColumnName, $dqlAlias)
+    {
+        return new self(sprintf(
+            'The discriminator column "%s" is missing for "%s" using the DQL alias "%s".',
+            $discrColumnName, $entityName, $dqlAlias
+        ));
+    }
+
+    /**
+     * @since 2.3
+     *
+     * @param string $entityName
+     * @param string $discrColumnName
+     * @param string $dqlAlias
+     *
+     * @return HydrationException
+     */
+    public static function missingDiscriminatorMetaMappingColumn($entityName, $discrColumnName, $dqlAlias)
+    {
+        return new self(sprintf(
+            'The meta mapping for the discriminator column "%s" is missing for "%s" using the DQL alias "%s".',
+            $discrColumnName, $entityName, $dqlAlias
+        ));
+    }
+
+    /**
+     * @param string $discrValue
+     * @param array  $discrMap
+     *
+     * @return HydrationException
+     */
+    public static function invalidDiscriminatorValue($discrValue, $discrMap)
+    {
+        return new self(sprintf(
+            'The discriminator value "%s" is invalid. It must be one of "%s".',
+            $discrValue, implode('", "', $discrMap)
+        ));
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/IterableResult.php

@@ -0,0 +1,110 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+/**
+ * Represents a result structure that can be iterated over, hydrating row-by-row
+ * during the iteration. An IterableResult is obtained by AbstractHydrator#iterate().
+ *
+ * @author robo
+ * @since 2.0
+ */
+class IterableResult implements \Iterator
+{
+    /**
+     * @var \Doctrine\ORM\Internal\Hydration\AbstractHydrator
+     */
+    private $_hydrator;
+
+    /**
+     * @var boolean
+     */
+    private $_rewinded = false;
+
+    /**
+     * @var integer
+     */
+    private $_key = -1;
+
+    /**
+     * @var object|null
+     */
+    private $_current = null;
+
+    /**
+     * @param \Doctrine\ORM\Internal\Hydration\AbstractHydrator $hydrator
+     */
+    public function __construct($hydrator)
+    {
+        $this->_hydrator = $hydrator;
+    }
+
+    /**
+     * @return void
+     *
+     * @throws HydrationException
+     */
+    public function rewind()
+    {
+        if ($this->_rewinded == true) {
+            throw new HydrationException("Can only iterate a Result once.");
+        } else {
+            $this->_current = $this->next();
+            $this->_rewinded = true;
+        }
+    }
+
+    /**
+     * Gets the next set of results.
+     *
+     * @return array|false
+     */
+    public function next()
+    {
+        $this->_current = $this->_hydrator->hydrateRow();
+        $this->_key++;
+
+        return $this->_current;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function current()
+    {
+        return $this->_current;
+    }
+
+    /**
+     * @return int
+     */
+    public function key()
+    {
+        return $this->_key;
+    }
+
+    /**
+     * @return bool
+     */
+    public function valid()
+    {
+        return ($this->_current!=false);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/ObjectHydrator.php

@@ -0,0 +1,593 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+use Doctrine\ORM\UnitOfWork;
+use PDO;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Query;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\ORM\Proxy\Proxy;
+
+/**
+ * The ObjectHydrator constructs an object graph out of an SQL result set.
+ *
+ * Internal note: Highly performance-sensitive code.
+ *
+ * @since  2.0
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class ObjectHydrator extends AbstractHydrator
+{
+    /**
+     * @var array
+     */
+    private $identifierMap = [];
+
+    /**
+     * @var array
+     */
+    private $resultPointers = [];
+
+    /**
+     * @var array
+     */
+    private $idTemplate = [];
+
+    /**
+     * @var integer
+     */
+    private $resultCounter = 0;
+
+    /**
+     * @var array
+     */
+    private $rootAliases = [];
+
+    /**
+     * @var array
+     */
+    private $initializedCollections = [];
+
+    /**
+     * @var array
+     */
+    private $existingCollections = [];
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function prepare()
+    {
+        if ( ! isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) {
+            $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] = true;
+        }
+
+        foreach ($this->_rsm->aliasMap as $dqlAlias => $className) {
+            $this->identifierMap[$dqlAlias] = [];
+            $this->idTemplate[$dqlAlias]    = '';
+
+            // Remember which associations are "fetch joined", so that we know where to inject
+            // collection stubs or proxies and where not.
+            if ( ! isset($this->_rsm->relationMap[$dqlAlias])) {
+                continue;
+            }
+
+            $parent = $this->_rsm->parentAliasMap[$dqlAlias];
+
+            if ( ! isset($this->_rsm->aliasMap[$parent])) {
+                throw HydrationException::parentObjectOfRelationNotFound($dqlAlias, $parent);
+            }
+
+            $sourceClassName = $this->_rsm->aliasMap[$parent];
+            $sourceClass     = $this->getClassMetadata($sourceClassName);
+            $assoc           = $sourceClass->associationMappings[$this->_rsm->relationMap[$dqlAlias]];
+
+            $this->_hints['fetched'][$parent][$assoc['fieldName']] = true;
+
+            if ($assoc['type'] === ClassMetadata::MANY_TO_MANY) {
+                continue;
+            }
+
+            // Mark any non-collection opposite sides as fetched, too.
+            if ($assoc['mappedBy']) {
+                $this->_hints['fetched'][$dqlAlias][$assoc['mappedBy']] = true;
+
+                continue;
+            }
+
+            // handle fetch-joined owning side bi-directional one-to-one associations
+            if ($assoc['inversedBy']) {
+                $class        = $this->getClassMetadata($className);
+                $inverseAssoc = $class->associationMappings[$assoc['inversedBy']];
+
+                if ( ! ($inverseAssoc['type'] & ClassMetadata::TO_ONE)) {
+                    continue;
+                }
+
+                $this->_hints['fetched'][$dqlAlias][$inverseAssoc['fieldName']] = true;
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function cleanup()
+    {
+        $eagerLoad = (isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) && $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] == true;
+
+        parent::cleanup();
+
+        $this->identifierMap =
+        $this->initializedCollections =
+        $this->existingCollections =
+        $this->resultPointers = [];
+
+        if ($eagerLoad) {
+            $this->_uow->triggerEagerLoads();
+        }
+
+        $this->_uow->hydrationComplete();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
+    {
+        $result = [];
+
+        while ($row = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
+            $this->hydrateRowData($row, $result);
+        }
+
+        // Take snapshots from all newly initialized collections
+        foreach ($this->initializedCollections as $coll) {
+            $coll->takeSnapshot();
+        }
+
+        return $result;
+    }
+
+    /**
+     * Initializes a related collection.
+     *
+     * @param object        $entity         The entity to which the collection belongs.
+     * @param ClassMetadata $class
+     * @param string        $fieldName      The name of the field on the entity that holds the collection.
+     * @param string        $parentDqlAlias Alias of the parent fetch joining this collection.
+     *
+     * @return \Doctrine\ORM\PersistentCollection
+     */
+    private function initRelatedCollection($entity, $class, $fieldName, $parentDqlAlias)
+    {
+        $oid      = spl_object_hash($entity);
+        $relation = $class->associationMappings[$fieldName];
+        $value    = $class->reflFields[$fieldName]->getValue($entity);
+
+        if ($value === null || is_array($value)) {
+            $value = new ArrayCollection((array) $value);
+        }
+
+        if ( ! $value instanceof PersistentCollection) {
+            $value = new PersistentCollection(
+                $this->_em, $this->_metadataCache[$relation['targetEntity']], $value
+            );
+            $value->setOwner($entity, $relation);
+
+            $class->reflFields[$fieldName]->setValue($entity, $value);
+            $this->_uow->setOriginalEntityProperty($oid, $fieldName, $value);
+
+            $this->initializedCollections[$oid . $fieldName] = $value;
+        } else if (
+            isset($this->_hints[Query::HINT_REFRESH]) ||
+            isset($this->_hints['fetched'][$parentDqlAlias][$fieldName]) &&
+             ! $value->isInitialized()
+        ) {
+            // Is already PersistentCollection, but either REFRESH or FETCH-JOIN and UNINITIALIZED!
+            $value->setDirty(false);
+            $value->setInitialized(true);
+            $value->unwrap()->clear();
+
+            $this->initializedCollections[$oid . $fieldName] = $value;
+        } else {
+            // Is already PersistentCollection, and DON'T REFRESH or FETCH-JOIN!
+            $this->existingCollections[$oid . $fieldName] = $value;
+        }
+
+        return $value;
+    }
+
+    /**
+     * Gets an entity instance.
+     *
+     * @param array  $data     The instance data.
+     * @param string $dqlAlias The DQL alias of the entity's class.
+     *
+     * @return object The entity.
+     *
+     * @throws HydrationException
+     */
+    private function getEntity(array $data, $dqlAlias)
+    {
+        $className = $this->_rsm->aliasMap[$dqlAlias];
+
+        if (isset($this->_rsm->discriminatorColumns[$dqlAlias])) {
+            $fieldName = $this->_rsm->discriminatorColumns[$dqlAlias];
+
+            if ( ! isset($this->_rsm->metaMappings[$fieldName])) {
+                throw HydrationException::missingDiscriminatorMetaMappingColumn($className, $fieldName, $dqlAlias);
+            }
+
+            $discrColumn = $this->_rsm->metaMappings[$fieldName];
+
+            if ( ! isset($data[$discrColumn])) {
+                throw HydrationException::missingDiscriminatorColumn($className, $discrColumn, $dqlAlias);
+            }
+
+            if ($data[$discrColumn] === "") {
+                throw HydrationException::emptyDiscriminatorValue($dqlAlias);
+            }
+
+            $discrMap = $this->_metadataCache[$className]->discriminatorMap;
+            $discriminatorValue = (string) $data[$discrColumn];
+
+            if ( ! isset($discrMap[$discriminatorValue])) {
+                throw HydrationException::invalidDiscriminatorValue($discriminatorValue, array_keys($discrMap));
+            }
+
+            $className = $discrMap[$discriminatorValue];
+
+            unset($data[$discrColumn]);
+        }
+
+        if (isset($this->_hints[Query::HINT_REFRESH_ENTITY]) && isset($this->rootAliases[$dqlAlias])) {
+            $this->registerManaged($this->_metadataCache[$className], $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
+        }
+
+        $this->_hints['fetchAlias'] = $dqlAlias;
+
+        return $this->_uow->createEntity($className, $data, $this->_hints);
+    }
+
+    /**
+     * @param string $className
+     * @param array  $data
+     *
+     * @return mixed
+     */
+    private function getEntityFromIdentityMap($className, array $data)
+    {
+        // TODO: Abstract this code and UnitOfWork::createEntity() equivalent?
+        $class = $this->_metadataCache[$className];
+
+        /* @var $class ClassMetadata */
+        if ($class->isIdentifierComposite) {
+            $idHash = '';
+
+            foreach ($class->identifier as $fieldName) {
+                $idHash .= ' ' . (isset($class->associationMappings[$fieldName])
+                    ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
+                    : $data[$fieldName]);
+            }
+
+            return $this->_uow->tryGetByIdHash(ltrim($idHash), $class->rootEntityName);
+        } else if (isset($class->associationMappings[$class->identifier[0]])) {
+            return $this->_uow->tryGetByIdHash($data[$class->associationMappings[$class->identifier[0]]['joinColumns'][0]['name']], $class->rootEntityName);
+        }
+
+        return $this->_uow->tryGetByIdHash($data[$class->identifier[0]], $class->rootEntityName);
+    }
+
+    /**
+     * Hydrates a single row in an SQL result set.
+     *
+     * @internal
+     * First, the data of the row is split into chunks where each chunk contains data
+     * that belongs to a particular component/class. Afterwards, all these chunks
+     * are processed, one after the other. For each chunk of class data only one of the
+     * following code paths is executed:
+     *
+     * Path A: The data chunk belongs to a joined/associated object and the association
+     *         is collection-valued.
+     * Path B: The data chunk belongs to a joined/associated object and the association
+     *         is single-valued.
+     * Path C: The data chunk belongs to a root result element/object that appears in the topmost
+     *         level of the hydrated result. A typical example are the objects of the type
+     *         specified by the FROM clause in a DQL query.
+     *
+     * @param array $row    The data of the row to process.
+     * @param array $result The result array to fill.
+     *
+     * @return void
+     */
+    protected function hydrateRowData(array $row, array &$result)
+    {
+        // Initialize
+        $id = $this->idTemplate; // initialize the id-memory
+        $nonemptyComponents = [];
+        // Split the row data into chunks of class data.
+        $rowData = $this->gatherRowData($row, $id, $nonemptyComponents);
+
+        // reset result pointers for each data row
+        $this->resultPointers = [];
+
+        // Hydrate the data chunks
+        foreach ($rowData['data'] as $dqlAlias => $data) {
+            $entityName = $this->_rsm->aliasMap[$dqlAlias];
+
+            if (isset($this->_rsm->parentAliasMap[$dqlAlias])) {
+                // It's a joined result
+
+                $parentAlias = $this->_rsm->parentAliasMap[$dqlAlias];
+                // we need the $path to save into the identifier map which entities were already
+                // seen for this parent-child relationship
+                $path = $parentAlias . '.' . $dqlAlias;
+
+                // We have a RIGHT JOIN result here. Doctrine cannot hydrate RIGHT JOIN Object-Graphs
+                if ( ! isset($nonemptyComponents[$parentAlias])) {
+                    // TODO: Add special case code where we hydrate the right join objects into identity map at least
+                    continue;
+                }
+
+                $parentClass    = $this->_metadataCache[$this->_rsm->aliasMap[$parentAlias]];
+                $relationField  = $this->_rsm->relationMap[$dqlAlias];
+                $relation       = $parentClass->associationMappings[$relationField];
+                $reflField      = $parentClass->reflFields[$relationField];
+
+                // Get a reference to the parent object to which the joined element belongs.
+                if ($this->_rsm->isMixed && isset($this->rootAliases[$parentAlias])) {
+                    $objectClass = $this->resultPointers[$parentAlias];
+                    $parentObject = $objectClass[key($objectClass)];
+                } else if (isset($this->resultPointers[$parentAlias])) {
+                    $parentObject = $this->resultPointers[$parentAlias];
+                } else {
+                    // Parent object of relation not found, mark as not-fetched again
+                    $element = $this->getEntity($data, $dqlAlias);
+
+                    // Update result pointer and provide initial fetch data for parent
+                    $this->resultPointers[$dqlAlias] = $element;
+                    $rowData['data'][$parentAlias][$relationField] = $element;
+
+                    // Mark as not-fetched again
+                    unset($this->_hints['fetched'][$parentAlias][$relationField]);
+                    continue;
+                }
+
+                $oid = spl_object_hash($parentObject);
+
+                // Check the type of the relation (many or single-valued)
+                if ( ! ($relation['type'] & ClassMetadata::TO_ONE)) {
+                    // PATH A: Collection-valued association
+                    $reflFieldValue = $reflField->getValue($parentObject);
+
+                    if (isset($nonemptyComponents[$dqlAlias])) {
+                        $collKey = $oid . $relationField;
+                        if (isset($this->initializedCollections[$collKey])) {
+                            $reflFieldValue = $this->initializedCollections[$collKey];
+                        } else if ( ! isset($this->existingCollections[$collKey])) {
+                            $reflFieldValue = $this->initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
+                        }
+
+                        $indexExists    = isset($this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]]);
+                        $index          = $indexExists ? $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] : false;
+                        $indexIsValid   = $index !== false ? isset($reflFieldValue[$index]) : false;
+
+                        if ( ! $indexExists || ! $indexIsValid) {
+                            if (isset($this->existingCollections[$collKey])) {
+                                // Collection exists, only look for the element in the identity map.
+                                if ($element = $this->getEntityFromIdentityMap($entityName, $data)) {
+                                    $this->resultPointers[$dqlAlias] = $element;
+                                } else {
+                                    unset($this->resultPointers[$dqlAlias]);
+                                }
+                            } else {
+                                $element = $this->getEntity($data, $dqlAlias);
+
+                                if (isset($this->_rsm->indexByMap[$dqlAlias])) {
+                                    $indexValue = $row[$this->_rsm->indexByMap[$dqlAlias]];
+                                    $reflFieldValue->hydrateSet($indexValue, $element);
+                                    $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $indexValue;
+                                } else {
+                                    $reflFieldValue->hydrateAdd($element);
+                                    $reflFieldValue->last();
+                                    $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $reflFieldValue->key();
+                                }
+                                // Update result pointer
+                                $this->resultPointers[$dqlAlias] = $element;
+                            }
+                        } else {
+                            // Update result pointer
+                            $this->resultPointers[$dqlAlias] = $reflFieldValue[$index];
+                        }
+                    } else if ( ! $reflFieldValue) {
+                        $this->initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
+                    } else if ($reflFieldValue instanceof PersistentCollection && $reflFieldValue->isInitialized() === false) {
+                        $reflFieldValue->setInitialized(true);
+                    }
+
+                } else {
+                    // PATH B: Single-valued association
+                    $reflFieldValue = $reflField->getValue($parentObject);
+
+                    if ( ! $reflFieldValue || isset($this->_hints[Query::HINT_REFRESH]) || ($reflFieldValue instanceof Proxy && !$reflFieldValue->__isInitialized__)) {
+                        // we only need to take action if this value is null,
+                        // we refresh the entity or its an uninitialized proxy.
+                        if (isset($nonemptyComponents[$dqlAlias])) {
+                            $element = $this->getEntity($data, $dqlAlias);
+                            $reflField->setValue($parentObject, $element);
+                            $this->_uow->setOriginalEntityProperty($oid, $relationField, $element);
+                            $targetClass = $this->_metadataCache[$relation['targetEntity']];
+
+                            if ($relation['isOwningSide']) {
+                                // TODO: Just check hints['fetched'] here?
+                                // If there is an inverse mapping on the target class its bidirectional
+                                if ($relation['inversedBy']) {
+                                    $inverseAssoc = $targetClass->associationMappings[$relation['inversedBy']];
+                                    if ($inverseAssoc['type'] & ClassMetadata::TO_ONE) {
+                                        $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($element, $parentObject);
+                                        $this->_uow->setOriginalEntityProperty(spl_object_hash($element), $inverseAssoc['fieldName'], $parentObject);
+                                    }
+                                } else if ($parentClass === $targetClass && $relation['mappedBy']) {
+                                    // Special case: bi-directional self-referencing one-one on the same class
+                                    $targetClass->reflFields[$relationField]->setValue($element, $parentObject);
+                                }
+                            } else {
+                                // For sure bidirectional, as there is no inverse side in unidirectional mappings
+                                $targetClass->reflFields[$relation['mappedBy']]->setValue($element, $parentObject);
+                                $this->_uow->setOriginalEntityProperty(spl_object_hash($element), $relation['mappedBy'], $parentObject);
+                            }
+                            // Update result pointer
+                            $this->resultPointers[$dqlAlias] = $element;
+                        } else {
+                            $this->_uow->setOriginalEntityProperty($oid, $relationField, null);
+                            $reflField->setValue($parentObject, null);
+                        }
+                        // else leave $reflFieldValue null for single-valued associations
+                    } else {
+                        // Update result pointer
+                        $this->resultPointers[$dqlAlias] = $reflFieldValue;
+                    }
+                }
+            } else {
+                // PATH C: Its a root result element
+                $this->rootAliases[$dqlAlias] = true; // Mark as root alias
+                $entityKey = $this->_rsm->entityMappings[$dqlAlias] ?: 0;
+
+                // if this row has a NULL value for the root result id then make it a null result.
+                if ( ! isset($nonemptyComponents[$dqlAlias]) ) {
+                    if ($this->_rsm->isMixed) {
+                        $result[] = [$entityKey => null];
+                    } else {
+                        $result[] = null;
+                    }
+                    $resultKey = $this->resultCounter;
+                    ++$this->resultCounter;
+                    continue;
+                }
+
+                // check for existing result from the iterations before
+                if ( ! isset($this->identifierMap[$dqlAlias][$id[$dqlAlias]])) {
+                    $element = $this->getEntity($data, $dqlAlias);
+
+                    if ($this->_rsm->isMixed) {
+                        $element = [$entityKey => $element];
+                    }
+
+                    if (isset($this->_rsm->indexByMap[$dqlAlias])) {
+                        $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
+
+                        if (isset($this->_hints['collection'])) {
+                            $this->_hints['collection']->hydrateSet($resultKey, $element);
+                        }
+
+                        $result[$resultKey] = $element;
+                    } else {
+                        $resultKey = $this->resultCounter;
+                        ++$this->resultCounter;
+
+                        if (isset($this->_hints['collection'])) {
+                            $this->_hints['collection']->hydrateAdd($element);
+                        }
+
+                        $result[] = $element;
+                    }
+
+                    $this->identifierMap[$dqlAlias][$id[$dqlAlias]] = $resultKey;
+
+                    // Update result pointer
+                    $this->resultPointers[$dqlAlias] = $element;
+
+                } else {
+                    // Update result pointer
+                    $index = $this->identifierMap[$dqlAlias][$id[$dqlAlias]];
+                    $this->resultPointers[$dqlAlias] = $result[$index];
+                    $resultKey = $index;
+                }
+            }
+
+            if (isset($this->_hints[Query::HINT_INTERNAL_ITERATION]) && $this->_hints[Query::HINT_INTERNAL_ITERATION]) {
+                $this->_uow->hydrationComplete();
+            }
+        }
+
+        if ( ! isset($resultKey) ) {
+            $this->resultCounter++;
+        }
+
+        // Append scalar values to mixed result sets
+        if (isset($rowData['scalars'])) {
+            if ( ! isset($resultKey) ) {
+                $resultKey = (isset($this->_rsm->indexByMap['scalars']))
+                    ? $row[$this->_rsm->indexByMap['scalars']]
+                    : $this->resultCounter - 1;
+            }
+
+            foreach ($rowData['scalars'] as $name => $value) {
+                $result[$resultKey][$name] = $value;
+            }
+        }
+
+        // Append new object to mixed result sets
+        if (isset($rowData['newObjects'])) {
+            if ( ! isset($resultKey) ) {
+                $resultKey = $this->resultCounter - 1;
+            }
+
+
+            $scalarCount = (isset($rowData['scalars'])? count($rowData['scalars']): 0);
+
+            foreach ($rowData['newObjects'] as $objIndex => $newObject) {
+                $class  = $newObject['class'];
+                $args   = $newObject['args'];
+                $obj    = $class->newInstanceArgs($args);
+
+                if ($scalarCount == 0 && count($rowData['newObjects']) == 1 ) {
+                    $result[$resultKey] = $obj;
+
+                    continue;
+                }
+
+                $result[$resultKey][$objIndex] = $obj;
+            }
+        }
+    }
+
+    /**
+     * When executed in a hydrate() loop we may have to clear internal state to
+     * decrease memory consumption.
+     *
+     * @param mixed $eventArgs
+     *
+     * @return void
+     */
+    public function onClear($eventArgs)
+    {
+        parent::onClear($eventArgs);
+
+        $aliases             = array_keys($this->identifierMap);
+
+        $this->identifierMap = array_fill_keys($aliases, []);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/ScalarHydrator.php

@@ -0,0 +1,54 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+/**
+ * Hydrator that produces flat, rectangular results of scalar data.
+ * The created result is almost the same as a regular SQL result set, except
+ * that column names are mapped to field names and data type conversions take place.
+ *
+ * @since  2.0
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ */
+class ScalarHydrator extends AbstractHydrator
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
+    {
+        $result = [];
+
+        while ($data = $this->_stmt->fetch(\PDO::FETCH_ASSOC)) {
+            $this->hydrateRowData($data, $result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateRowData(array $row, array &$result)
+    {
+        $result[] = $this->gatherScalarRowData($row);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/SimpleObjectHydrator.php

@@ -0,0 +1,163 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+use PDO;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Query;
+use function array_keys;
+use function in_array;
+
+class SimpleObjectHydrator extends AbstractHydrator
+{
+    /**
+     * @var ClassMetadata
+     */
+    private $class;
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function prepare()
+    {
+        if (count($this->_rsm->aliasMap) !== 1) {
+            throw new \RuntimeException("Cannot use SimpleObjectHydrator with a ResultSetMapping that contains more than one object result.");
+        }
+
+        if ($this->_rsm->scalarMappings) {
+            throw new \RuntimeException("Cannot use SimpleObjectHydrator with a ResultSetMapping that contains scalar mappings.");
+        }
+
+        $this->class = $this->getClassMetadata(reset($this->_rsm->aliasMap));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function cleanup()
+    {
+        parent::cleanup();
+
+        $this->_uow->triggerEagerLoads();
+        $this->_uow->hydrationComplete();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
+    {
+        $result = [];
+
+        while ($row = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
+            $this->hydrateRowData($row, $result);
+        }
+
+        $this->_em->getUnitOfWork()->triggerEagerLoads();
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateRowData(array $row, array &$result)
+    {
+        $entityName       = $this->class->name;
+        $data             = [];
+        $discrColumnValue = null;
+
+        // We need to find the correct entity class name if we have inheritance in resultset
+        if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
+            $discrColumnName = $this->_platform->getSQLResultCasing($this->class->discriminatorColumn['name']);
+
+            // Find mapped discriminator column from the result set.
+            if ($metaMappingDiscrColumnName = array_search($discrColumnName, $this->_rsm->metaMappings)) {
+                $discrColumnName = $metaMappingDiscrColumnName;
+            }
+
+            if (! isset($row[$discrColumnName])) {
+                throw HydrationException::missingDiscriminatorColumn($entityName, $discrColumnName, key($this->_rsm->aliasMap));
+            }
+
+            if ($row[$discrColumnName] === '') {
+                throw HydrationException::emptyDiscriminatorValue(key($this->_rsm->aliasMap));
+            }
+
+            $discrMap = $this->class->discriminatorMap;
+
+            if (! isset($discrMap[$row[$discrColumnName]])) {
+                throw HydrationException::invalidDiscriminatorValue($row[$discrColumnName], array_keys($discrMap));
+            }
+
+            $entityName       = $discrMap[$row[$discrColumnName]];
+            $discrColumnValue = $row[$discrColumnName];
+
+            unset($row[$discrColumnName]);
+        }
+
+        foreach ($row as $column => $value) {
+            // An ObjectHydrator should be used instead of SimpleObjectHydrator
+            if (isset($this->_rsm->relationMap[$column])) {
+                throw new \Exception(sprintf('Unable to retrieve association information for column "%s"', $column));
+            }
+
+            $cacheKeyInfo = $this->hydrateColumnInfo($column);
+
+            if ( ! $cacheKeyInfo) {
+                continue;
+            }
+
+            // Check if value is null before conversion (because some types convert null to something else)
+            $valueIsNull = null === $value;
+
+            // Convert field to a valid PHP value
+            if (isset($cacheKeyInfo['type'])) {
+                $type  = $cacheKeyInfo['type'];
+                $value = $type->convertToPHPValue($value, $this->_platform);
+            }
+
+            $fieldName = $cacheKeyInfo['fieldName'];
+
+            // Prevent overwrite in case of inherit classes using same property name (See AbstractHydrator)
+            if ( ! isset($data[$fieldName]) || ! $valueIsNull) {
+                // If we have inheritance in resultset, make sure the field belongs to the correct class
+                if (isset($cacheKeyInfo['discriminatorValues']) && ! in_array((string) $discrColumnValue, $cacheKeyInfo['discriminatorValues'], true)) {
+                    continue;
+                }
+
+                $data[$fieldName] = $value;
+            }
+        }
+
+        if (isset($this->_hints[Query::HINT_REFRESH_ENTITY])) {
+            $this->registerManaged($this->class, $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
+        }
+
+        $uow    = $this->_em->getUnitOfWork();
+        $entity = $uow->createEntity($entityName, $data, $this->_hints);
+
+        $result[] = $entity;
+
+        if (isset($this->_hints[Query::HINT_INTERNAL_ITERATION]) && $this->_hints[Query::HINT_INTERNAL_ITERATION]) {
+            $this->_uow->hydrationComplete();
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/SingleScalarHydrator.php

@@ -0,0 +1,58 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal\Hydration;
+
+use Doctrine\ORM\NoResultException;
+use Doctrine\ORM\NonUniqueResultException;
+
+/**
+ * Hydrator that hydrates a single scalar value from the result set.
+ *
+ * @since  2.0
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ */
+class SingleScalarHydrator extends AbstractHydrator
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
+    {
+        $data    = $this->_stmt->fetchAll(\PDO::FETCH_ASSOC);
+        $numRows = count($data);
+
+        if ($numRows === 0) {
+            throw new NoResultException();
+        }
+
+        if ($numRows > 1) {
+            throw new NonUniqueResultException('The query returned multiple rows. Change the query or use a different result function like getScalarResult().');
+        }
+        
+        if (count($data[key($data)]) > 1) {
+            throw new NonUniqueResultException('The query returned a row containing multiple columns. Change the query or use a different result function like getScalarResult().');
+        }
+
+        $result = $this->gatherScalarRowData($data[key($data)]);
+
+        return array_shift($result);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/HydrationCompleteHandler.php

@@ -0,0 +1,103 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Internal;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\LifecycleEventArgs;
+use Doctrine\ORM\Event\ListenersInvoker;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+/**
+ * Class, which can handle completion of hydration cycle and produce some of tasks.
+ * In current implementation triggers deferred postLoad event.
+ *
+ * @author Artur Eshenbrener <strate@yandex.ru>
+ * @since 2.5
+ */
+final class HydrationCompleteHandler
+{
+    /**
+     * @var ListenersInvoker
+     */
+    private $listenersInvoker;
+
+    /**
+     * @var EntityManagerInterface
+     */
+    private $em;
+
+    /**
+     * @var array[]
+     */
+    private $deferredPostLoadInvocations = [];
+
+    /**
+     * Constructor for this object
+     *
+     * @param ListenersInvoker $listenersInvoker
+     * @param EntityManagerInterface $em
+     */
+    public function __construct(ListenersInvoker $listenersInvoker, EntityManagerInterface $em)
+    {
+        $this->listenersInvoker = $listenersInvoker;
+        $this->em               = $em;
+    }
+
+    /**
+     * Method schedules invoking of postLoad entity to the very end of current hydration cycle.
+     *
+     * @param ClassMetadata $class
+     * @param object        $entity
+     */
+    public function deferPostLoadInvoking(ClassMetadata $class, $entity)
+    {
+        $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postLoad);
+
+        if ($invoke === ListenersInvoker::INVOKE_NONE) {
+            return;
+        }
+
+        $this->deferredPostLoadInvocations[] = [$class, $invoke, $entity];
+    }
+
+    /**
+     * This method should me called after any hydration cycle completed.
+     *
+     * Method fires all deferred invocations of postLoad events
+     */
+    public function hydrationComplete()
+    {
+        $toInvoke                          = $this->deferredPostLoadInvocations;
+        $this->deferredPostLoadInvocations = [];
+
+        foreach ($toInvoke as $classAndEntity) {
+            [$class, $invoke, $entity] = $classAndEntity;
+
+            $this->listenersInvoker->invoke(
+                $class,
+                Events::postLoad,
+                $entity,
+                new LifecycleEventArgs($entity, $this->em),
+                $invoke
+            );
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/LazyCriteriaCollection.php

@@ -0,0 +1,133 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM;
+
+use Doctrine\Common\Collections\AbstractLazyCollection;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Criteria;
+use Doctrine\Common\Collections\Selectable;
+use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
+use Doctrine\ORM\Persisters\Entity\EntityPersister;
+
+/**
+ * A lazy collection that allow a fast count when using criteria object
+ * Once count gets executed once without collection being initialized, result
+ * is cached and returned on subsequent calls until collection gets loaded,
+ * then returning the number of loaded results.
+ *
+ * @since   2.5
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author  Michaël Gallego <mic.gallego@gmail.com>
+ */
+class LazyCriteriaCollection extends AbstractLazyCollection implements Selectable
+{
+    /**
+     * @var BasicEntityPersister
+     */
+    protected $entityPersister;
+
+    /**
+     * @var Criteria
+     */
+    protected $criteria;
+
+    /**
+     * @var integer|null
+     */
+    private $count;
+
+    /**
+     * @param EntityPersister $entityPersister
+     * @param Criteria        $criteria
+     */
+    public function __construct(EntityPersister $entityPersister, Criteria $criteria)
+    {
+        $this->entityPersister = $entityPersister;
+        $this->criteria        = $criteria;
+    }
+
+    /**
+     * Do an efficient count on the collection
+     *
+     * @return integer
+     */
+    public function count()
+    {
+        if ($this->isInitialized()) {
+            return $this->collection->count();
+        }
+
+        // Return cached result in case count query was already executed
+        if ($this->count !== null) {
+            return $this->count;
+        }
+
+        return $this->count = $this->entityPersister->count($this->criteria);
+    }
+
+    /**
+     * check if collection is empty without loading it
+     *
+     * @return boolean TRUE if the collection is empty, FALSE otherwise.
+     */
+    public function isEmpty()
+    {
+        if ($this->isInitialized()) {
+            return $this->collection->isEmpty();
+        }
+
+        return !$this->count();
+    }
+
+    /**
+     * Do an optimized search of an element
+     *
+     * @param object $element
+     *
+     * @return bool
+     */
+    public function contains($element)
+    {
+        if ($this->isInitialized()) {
+            return $this->collection->contains($element);
+        }
+
+        return $this->entityPersister->exists($element, $this->criteria);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function matching(Criteria $criteria)
+    {
+        $this->initialize();
+
+        return $this->collection->matching($criteria);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function doInitialize()
+    {
+        $elements         = $this->entityPersister->loadCriteria($this->criteria);
+        $this->collection = new ArrayCollection($elements);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Annotation.php

@@ -0,0 +1,24 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+interface Annotation
+{
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/AnsiQuoteStrategy.php

@@ -0,0 +1,96 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+/**
+ * ANSI compliant quote strategy, this strategy does not apply any quote.
+ * To use this strategy all mapped tables and columns should be ANSI compliant.
+ * 
+ * @since   2.5
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class AnsiQuoteStrategy implements QuoteStrategy
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getColumnName($fieldName, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $class->fieldMappings[$fieldName]['columnName'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTableName(ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $class->table['name'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSequenceName(array $definition, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $definition['sequenceName'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getJoinColumnName(array $joinColumn, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $joinColumn['name'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getReferencedJoinColumnName(array $joinColumn, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $joinColumn['referencedColumnName'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getJoinTableName(array $association, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $association['joinTable']['name'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getIdentifierColumnNames(ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return $class->identifier;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getColumnAlias($columnName, $counter, AbstractPlatform $platform, ClassMetadata $class = null)
+    {
+        return $platform->getSQLResultCasing($columnName . '_' . $counter);
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/AssociationOverride.php

@@ -0,0 +1,69 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override association mapping of property for an entity relationship.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class AssociationOverride implements Annotation
+{
+    /**
+     * The name of the relationship property whose mapping is being overridden.
+     * 
+     * @var string 
+     */
+    public $name;
+
+    /**
+     * The join column that is being mapped to the persistent attribute.
+     *
+     * @var array<\Doctrine\ORM\Mapping\JoinColumn>
+     */
+    public $joinColumns;
+
+    /**
+     * The join table that maps the relationship.
+     *
+     * @var \Doctrine\ORM\Mapping\JoinTable
+     */
+    public $joinTable;
+
+    /**
+     * The name of the association-field on the inverse-side.
+     *
+     * @var string
+     */
+    public $inversedBy;
+
+    /**
+     * The fetching strategy to use for the association.
+     *
+     * @var string
+     *
+     * @Enum({"LAZY", "EAGER", "EXTRA_LAZY"})
+     */
+    public $fetch;
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/AssociationOverrides.php

@@ -0,0 +1,39 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override association mappings of relationship properties.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class AssociationOverrides implements Annotation
+{
+    /**
+     * Mapping overrides of relationship properties.
+     *
+     * @var array<\Doctrine\ORM\Mapping\AssociationOverride> 
+     */
+    public $value;
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/AttributeOverride.php

@@ -0,0 +1,46 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override the mapping of a entity property.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class AttributeOverride implements Annotation
+{
+    /**
+     * The name of the property whose mapping is being overridden.
+     * 
+     * @var string 
+     */
+    public $name;
+
+    /**
+     * The column definition.
+     *
+     * @var \Doctrine\ORM\Mapping\Column
+     */
+    public $column;
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/AttributeOverrides.php

@@ -0,0 +1,39 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override the mapping of a entity property.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class AttributeOverrides implements Annotation
+{
+    /**
+     * One or more field or property mapping overrides.
+     *
+     * @var array<\Doctrine\ORM\Mapping\AttributeOverride>
+     */
+    public $value;
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/AssociationBuilder.php

@@ -0,0 +1,244 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+class AssociationBuilder
+{
+    /**
+     * @var ClassMetadataBuilder
+     */
+    protected $builder;
+
+    /**
+     * @var array
+     */
+    protected $mapping;
+
+    /**
+     * @var array|null
+     */
+    protected $joinColumns;
+
+    /**
+     * @var int
+     */
+    protected $type;
+
+    /**
+     * @param ClassMetadataBuilder $builder
+     * @param array                $mapping
+     * @param int                  $type
+     */
+    public function __construct(ClassMetadataBuilder $builder, array $mapping, $type)
+    {
+        $this->builder = $builder;
+        $this->mapping = $mapping;
+        $this->type = $type;
+    }
+
+    /**
+     * @param string $fieldName
+     *
+     * @return static
+     */
+    public function mappedBy($fieldName)
+    {
+        $this->mapping['mappedBy'] = $fieldName;
+
+        return $this;
+    }
+
+    /**
+     * @param string $fieldName
+     *
+     * @return static
+     */
+    public function inversedBy($fieldName)
+    {
+        $this->mapping['inversedBy'] = $fieldName;
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function cascadeAll()
+    {
+        $this->mapping['cascade'] = ["ALL"];
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function cascadePersist()
+    {
+        $this->mapping['cascade'][] = "persist";
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function cascadeRemove()
+    {
+        $this->mapping['cascade'][] = "remove";
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function cascadeMerge()
+    {
+        $this->mapping['cascade'][] = "merge";
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function cascadeDetach()
+    {
+        $this->mapping['cascade'][] = "detach";
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function cascadeRefresh()
+    {
+        $this->mapping['cascade'][] = "refresh";
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function fetchExtraLazy()
+    {
+        $this->mapping['fetch'] = ClassMetadata::FETCH_EXTRA_LAZY;
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function fetchEager()
+    {
+        $this->mapping['fetch'] = ClassMetadata::FETCH_EAGER;
+
+        return $this;
+    }
+
+    /**
+     * @return static
+     */
+    public function fetchLazy()
+    {
+        $this->mapping['fetch'] = ClassMetadata::FETCH_LAZY;
+
+        return $this;
+    }
+
+    /**
+     * Add Join Columns.
+     *
+     * @param string      $columnName
+     * @param string      $referencedColumnName
+     * @param bool        $nullable
+     * @param bool        $unique
+     * @param string|null $onDelete
+     * @param string|null $columnDef
+     *
+     * @return static
+     */
+    public function addJoinColumn($columnName, $referencedColumnName, $nullable = true, $unique = false, $onDelete = null, $columnDef = null)
+    {
+        $this->joinColumns[] = [
+            'name' => $columnName,
+            'referencedColumnName' => $referencedColumnName,
+            'nullable' => $nullable,
+            'unique' => $unique,
+            'onDelete' => $onDelete,
+            'columnDefinition' => $columnDef,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Sets field as primary key.
+     *
+     * @return static
+     */
+    public function makePrimaryKey()
+    {
+        $this->mapping['id'] = true;
+
+        return $this;
+    }
+
+    /**
+     * Removes orphan entities when detached from their parent.
+     *
+     * @return static
+     */
+    public function orphanRemoval()
+    {
+        $this->mapping['orphanRemoval'] = true;
+
+        return $this;
+    }
+
+    /**
+     * @return ClassMetadataBuilder
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function build()
+    {
+        $mapping = $this->mapping;
+        if ($this->joinColumns) {
+            $mapping['joinColumns'] = $this->joinColumns;
+        }
+        $cm = $this->builder->getClassMetadata();
+        if ($this->type == ClassMetadata::MANY_TO_ONE) {
+            $cm->mapManyToOne($mapping);
+        } else if ($this->type == ClassMetadata::ONE_TO_ONE) {
+            $cm->mapOneToOne($mapping);
+        } else {
+            throw new \InvalidArgumentException("Type should be a ToOne Association here");
+        }
+
+        return $this->builder;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/ClassMetadataBuilder.php

@@ -0,0 +1,553 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Mapping\ClassMetadataInfo;
+
+/**
+ * Builder Object for ClassMetadata
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.com
+ * @since       2.2
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ */
+class ClassMetadataBuilder
+{
+    /**
+     * @var \Doctrine\ORM\Mapping\ClassMetadataInfo
+     */
+    private $cm;
+
+    /**
+     * @param \Doctrine\ORM\Mapping\ClassMetadataInfo $cm
+     */
+    public function __construct(ClassMetadataInfo $cm)
+    {
+        $this->cm = $cm;
+    }
+
+    /**
+     * @return ClassMetadata
+     */
+    public function getClassMetadata()
+    {
+        return $this->cm;
+    }
+
+    /**
+     * Marks the class as mapped superclass.
+     *
+     * @return static
+     */
+    public function setMappedSuperClass()
+    {
+        $this->cm->isMappedSuperclass = true;
+        $this->cm->isEmbeddedClass = false;
+
+        return $this;
+    }
+
+    /**
+     * Marks the class as embeddable.
+     *
+     * @return static
+     */
+    public function setEmbeddable()
+    {
+        $this->cm->isEmbeddedClass = true;
+        $this->cm->isMappedSuperclass = false;
+
+        return $this;
+    }
+
+    /**
+     * Adds and embedded class
+     *
+     * @param string      $fieldName
+     * @param string      $class
+     * @param string|null $columnPrefix
+     *
+     * @return $this
+     */
+    public function addEmbedded($fieldName, $class, $columnPrefix = null)
+    {
+        $this->cm->mapEmbedded(
+            [
+                'fieldName'    => $fieldName,
+                'class'        => $class,
+                'columnPrefix' => $columnPrefix
+            ]
+        );
+
+        return $this;
+    }
+
+    /**
+     * Sets custom Repository class name.
+     *
+     * @param string $repositoryClassName
+     *
+     * @return static
+     */
+    public function setCustomRepositoryClass($repositoryClassName)
+    {
+        $this->cm->setCustomRepositoryClass($repositoryClassName);
+
+        return $this;
+    }
+
+    /**
+     * Marks class read only.
+     *
+     * @return static
+     */
+    public function setReadOnly()
+    {
+        $this->cm->markReadOnly();
+
+        return $this;
+    }
+
+    /**
+     * Sets the table name.
+     *
+     * @param string $name
+     *
+     * @return static
+     */
+    public function setTable($name)
+    {
+        $this->cm->setPrimaryTable(['name' => $name]);
+
+        return $this;
+    }
+
+    /**
+     * Adds Index.
+     *
+     * @param array  $columns
+     * @param string $name
+     *
+     * @return static
+     */
+    public function addIndex(array $columns, $name)
+    {
+        if (!isset($this->cm->table['indexes'])) {
+            $this->cm->table['indexes'] = [];
+        }
+
+        $this->cm->table['indexes'][$name] = ['columns' => $columns];
+
+        return $this;
+    }
+
+    /**
+     * Adds Unique Constraint.
+     *
+     * @param array  $columns
+     * @param string $name
+     *
+     * @return static
+     */
+    public function addUniqueConstraint(array $columns, $name)
+    {
+        if ( ! isset($this->cm->table['uniqueConstraints'])) {
+            $this->cm->table['uniqueConstraints'] = [];
+        }
+
+        $this->cm->table['uniqueConstraints'][$name] = ['columns' => $columns];
+
+        return $this;
+    }
+
+    /**
+     * Adds named query.
+     *
+     * @param string $name
+     * @param string $dqlQuery
+     *
+     * @return static
+     */
+    public function addNamedQuery($name, $dqlQuery)
+    {
+        $this->cm->addNamedQuery(
+            [
+                'name' => $name,
+                'query' => $dqlQuery,
+            ]
+        );
+
+        return $this;
+    }
+
+    /**
+     * Sets class as root of a joined table inheritance hierarchy.
+     *
+     * @return static
+     */
+    public function setJoinedTableInheritance()
+    {
+        $this->cm->setInheritanceType(ClassMetadata::INHERITANCE_TYPE_JOINED);
+
+        return $this;
+    }
+
+    /**
+     * Sets class as root of a single table inheritance hierarchy.
+     *
+     * @return static
+     */
+    public function setSingleTableInheritance()
+    {
+        $this->cm->setInheritanceType(ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE);
+
+        return $this;
+    }
+
+    /**
+     * Sets the discriminator column details.
+     *
+     * @param string $name
+     * @param string $type
+     * @param int    $length
+     *
+     * @return static
+     */
+    public function setDiscriminatorColumn($name, $type = 'string', $length = 255)
+    {
+        $this->cm->setDiscriminatorColumn(
+            [
+                'name' => $name,
+                'type' => $type,
+                'length' => $length,
+            ]
+        );
+
+        return $this;
+    }
+
+    /**
+     * Adds a subclass to this inheritance hierarchy.
+     *
+     * @param string $name
+     * @param string $class
+     *
+     * @return static
+     */
+    public function addDiscriminatorMapClass($name, $class)
+    {
+        $this->cm->addDiscriminatorMapClass($name, $class);
+
+        return $this;
+    }
+
+    /**
+     * Sets deferred explicit change tracking policy.
+     *
+     * @return static
+     */
+    public function setChangeTrackingPolicyDeferredExplicit()
+    {
+        $this->cm->setChangeTrackingPolicy(ClassMetadata::CHANGETRACKING_DEFERRED_EXPLICIT);
+
+        return $this;
+    }
+
+    /**
+     * Sets notify change tracking policy.
+     *
+     * @return static
+     */
+    public function setChangeTrackingPolicyNotify()
+    {
+        $this->cm->setChangeTrackingPolicy(ClassMetadata::CHANGETRACKING_NOTIFY);
+
+        return $this;
+    }
+
+    /**
+     * Adds lifecycle event.
+     *
+     * @param string $methodName
+     * @param string $event
+     *
+     * @return static
+     */
+    public function addLifecycleEvent($methodName, $event)
+    {
+        $this->cm->addLifecycleCallback($methodName, $event);
+
+        return $this;
+    }
+
+    /**
+     * Adds Field.
+     *
+     * @param string $name
+     * @param string $type
+     * @param array  $mapping
+     *
+     * @return static
+     */
+    public function addField($name, $type, array $mapping = [])
+    {
+        $mapping['fieldName'] = $name;
+        $mapping['type'] = $type;
+
+        $this->cm->mapField($mapping);
+
+        return $this;
+    }
+
+    /**
+     * Creates a field builder.
+     *
+     * @param string $name
+     * @param string $type
+     *
+     * @return FieldBuilder
+     */
+    public function createField($name, $type)
+    {
+        return new FieldBuilder(
+            $this,
+            [
+                'fieldName' => $name,
+                'type'      => $type
+            ]
+        );
+    }
+
+    /**
+     * Creates an embedded builder.
+     *
+     * @param string $fieldName
+     * @param string $class
+     *
+     * @return EmbeddedBuilder
+     */
+    public function createEmbedded($fieldName, $class)
+    {
+        return new EmbeddedBuilder(
+            $this,
+            [
+                'fieldName'    => $fieldName,
+                'class'        => $class,
+                'columnPrefix' => null
+            ]
+        );
+    }
+
+    /**
+     * Adds a simple many to one association, optionally with the inversed by field.
+     *
+     * @param string      $name
+     * @param string      $targetEntity
+     * @param string|null $inversedBy
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function addManyToOne($name, $targetEntity, $inversedBy = null)
+    {
+        $builder = $this->createManyToOne($name, $targetEntity);
+
+        if ($inversedBy) {
+            $builder->inversedBy($inversedBy);
+        }
+
+        return $builder->build();
+    }
+
+    /**
+     * Creates a ManyToOne Association Builder.
+     *
+     * Note: This method does not add the association, you have to call build() on the AssociationBuilder.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     *
+     * @return AssociationBuilder
+     */
+    public function createManyToOne($name, $targetEntity)
+    {
+        return new AssociationBuilder(
+            $this,
+            [
+                'fieldName'    => $name,
+                'targetEntity' => $targetEntity
+            ],
+            ClassMetadata::MANY_TO_ONE
+        );
+    }
+
+    /**
+     * Creates a OneToOne Association Builder.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     *
+     * @return AssociationBuilder
+     */
+    public function createOneToOne($name, $targetEntity)
+    {
+        return new AssociationBuilder(
+            $this,
+            [
+                'fieldName'    => $name,
+                'targetEntity' => $targetEntity
+            ],
+            ClassMetadata::ONE_TO_ONE
+        );
+    }
+
+    /**
+     * Adds simple inverse one-to-one association.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     * @param string $mappedBy
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function addInverseOneToOne($name, $targetEntity, $mappedBy)
+    {
+        $builder = $this->createOneToOne($name, $targetEntity);
+        $builder->mappedBy($mappedBy);
+
+        return $builder->build();
+    }
+
+    /**
+     * Adds simple owning one-to-one association.
+     *
+     * @param string      $name
+     * @param string      $targetEntity
+     * @param string|null $inversedBy
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function addOwningOneToOne($name, $targetEntity, $inversedBy = null)
+    {
+        $builder = $this->createOneToOne($name, $targetEntity);
+
+        if ($inversedBy) {
+            $builder->inversedBy($inversedBy);
+        }
+
+        return $builder->build();
+    }
+
+    /**
+     * Creates a ManyToMany Association Builder.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     *
+     * @return ManyToManyAssociationBuilder
+     */
+    public function createManyToMany($name, $targetEntity)
+    {
+        return new ManyToManyAssociationBuilder(
+            $this,
+            [
+                'fieldName'    => $name,
+                'targetEntity' => $targetEntity
+            ],
+            ClassMetadata::MANY_TO_MANY
+        );
+    }
+
+    /**
+     * Adds a simple owning many to many association.
+     *
+     * @param string      $name
+     * @param string      $targetEntity
+     * @param string|null $inversedBy
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function addOwningManyToMany($name, $targetEntity, $inversedBy = null)
+    {
+        $builder = $this->createManyToMany($name, $targetEntity);
+
+        if ($inversedBy) {
+            $builder->inversedBy($inversedBy);
+        }
+
+        return $builder->build();
+    }
+
+    /**
+     * Adds a simple inverse many to many association.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     * @param string $mappedBy
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function addInverseManyToMany($name, $targetEntity, $mappedBy)
+    {
+        $builder = $this->createManyToMany($name, $targetEntity);
+        $builder->mappedBy($mappedBy);
+
+        return $builder->build();
+    }
+
+    /**
+     * Creates a one to many association builder.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     *
+     * @return OneToManyAssociationBuilder
+     */
+    public function createOneToMany($name, $targetEntity)
+    {
+        return new OneToManyAssociationBuilder(
+            $this,
+            [
+                'fieldName'    => $name,
+                'targetEntity' => $targetEntity
+            ],
+            ClassMetadata::ONE_TO_MANY
+        );
+    }
+
+    /**
+     * Adds simple OneToMany association.
+     *
+     * @param string $name
+     * @param string $targetEntity
+     * @param string $mappedBy
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function addOneToMany($name, $targetEntity, $mappedBy)
+    {
+        $builder = $this->createOneToMany($name, $targetEntity);
+        $builder->mappedBy($mappedBy);
+
+        return $builder->build();
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/EmbeddedBuilder.php

@@ -0,0 +1,80 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+/**
+ * Embedded Builder
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.com
+ * @since       2.5
+ * @author      Guido Contreras Woda <guiwoda@gmail.com>
+ */
+class EmbeddedBuilder
+{
+    /**
+     * @var ClassMetadataBuilder
+     */
+    private $builder;
+
+    /**
+     * @var array
+     */
+    private $mapping;
+
+    /**
+     * @param ClassMetadataBuilder $builder
+     * @param array                $mapping
+     */
+    public function __construct(ClassMetadataBuilder $builder, array $mapping)
+    {
+        $this->builder = $builder;
+        $this->mapping = $mapping;
+    }
+
+    /**
+     * Sets the column prefix for all of the embedded columns.
+     *
+     * @param string $columnPrefix
+     * @return $this
+     */
+    public function setColumnPrefix($columnPrefix)
+    {
+        $this->mapping['columnPrefix'] = $columnPrefix;
+
+        return $this;
+    }
+
+    /**
+     * Finalizes this embeddable and attach it to the ClassMetadata.
+     *
+     * Without this call an EmbeddedBuilder has no effect on the ClassMetadata.
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function build()
+    {
+        $cm = $this->builder->getClassMetadata();
+
+        $cm->mapEmbedded($this->mapping);
+
+        return $this->builder;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/EntityListenerBuilder.php

@@ -0,0 +1,72 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+use Doctrine\ORM\Mapping\MappingException;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Events;
+
+/**
+ * Builder for entity listeners.
+ *
+ * @since       2.4
+ * @author      Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class EntityListenerBuilder
+{
+    /**
+     * @var array Hash-map to handle event names.
+     */
+    static private $events = [
+        Events::preRemove   => true,
+        Events::postRemove  => true,
+        Events::prePersist  => true,
+        Events::postPersist => true,
+        Events::preUpdate   => true,
+        Events::postUpdate  => true,
+        Events::postLoad    => true,
+        Events::preFlush    => true
+    ];
+
+    /**
+     * Lookup the entity class to find methods that match to event lifecycle names
+     *
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata     The entity metadata.
+     * @param string $className                                 The listener class name.
+     *
+     * @throws \Doctrine\ORM\Mapping\MappingException           When the listener class not found.
+     */
+    static public function bindEntityListener(ClassMetadata $metadata, $className)
+    {
+        $class = $metadata->fullyQualifiedClassName($className);
+
+        if ( ! class_exists($class)) {
+            throw MappingException::entityListenerClassNotFound($class, $className);
+        }
+
+        foreach (get_class_methods($class) as $method) {
+            if ( ! isset(self::$events[$method])) {
+                continue;
+            }
+
+            $metadata->addEntityListener($method, $class, $method);
+        }
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/FieldBuilder.php

@@ -0,0 +1,296 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+/**
+ * Field Builder
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.com
+ * @since       2.2
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class FieldBuilder
+{
+    /**
+     * @var ClassMetadataBuilder
+     */
+    private $builder;
+
+    /**
+     * @var array
+     */
+    private $mapping;
+
+    /**
+     * @var bool
+     */
+    private $version;
+
+    /**
+     * @var string
+     */
+    private $generatedValue;
+
+    /**
+     * @var array
+     */
+    private $sequenceDef;
+
+    /**
+     * @var string|null
+     */
+    private $customIdGenerator;
+
+    /**
+     * @param ClassMetadataBuilder $builder
+     * @param array                $mapping
+     */
+    public function __construct(ClassMetadataBuilder $builder, array $mapping)
+    {
+        $this->builder = $builder;
+        $this->mapping = $mapping;
+    }
+
+    /**
+     * Sets length.
+     *
+     * @param int $length
+     *
+     * @return static
+     */
+    public function length($length)
+    {
+        $this->mapping['length'] = $length;
+
+        return $this;
+    }
+
+    /**
+     * Sets nullable.
+     *
+     * @param bool $flag
+     *
+     * @return static
+     */
+    public function nullable($flag = true)
+    {
+        $this->mapping['nullable'] = (bool) $flag;
+
+        return $this;
+    }
+
+    /**
+     * Sets Unique.
+     *
+     * @param bool $flag
+     *
+     * @return static
+     */
+    public function unique($flag = true)
+    {
+        $this->mapping['unique'] = (bool) $flag;
+
+        return $this;
+    }
+
+    /**
+     * Sets column name.
+     *
+     * @param string $name
+     *
+     * @return static
+     */
+    public function columnName($name)
+    {
+        $this->mapping['columnName'] = $name;
+
+        return $this;
+    }
+
+    /**
+     * Sets Precision.
+     *
+     * @param int $p
+     *
+     * @return static
+     */
+    public function precision($p)
+    {
+        $this->mapping['precision'] = $p;
+
+        return $this;
+    }
+
+    /**
+     * Sets scale.
+     *
+     * @param int $s
+     *
+     * @return static
+     */
+    public function scale($s)
+    {
+        $this->mapping['scale'] = $s;
+
+        return $this;
+    }
+
+    /**
+     * Sets field as primary key.
+     *
+     * @deprecated Use makePrimaryKey() instead
+     * @return FieldBuilder
+     */
+    public function isPrimaryKey()
+    {
+        return $this->makePrimaryKey();
+    }
+
+    /**
+     * Sets field as primary key.
+     *
+     * @return static
+     */
+    public function makePrimaryKey()
+    {
+        $this->mapping['id'] = true;
+
+        return $this;
+    }
+
+    /**
+     * Sets an option.
+     *
+     * @param string $name
+     * @param mixed  $value
+     *
+     * @return static
+     */
+    public function option($name, $value)
+    {
+        $this->mapping['options'][$name] = $value;
+
+        return $this;
+    }
+
+    /**
+     * @param string $strategy
+     *
+     * @return static
+     */
+    public function generatedValue($strategy = 'AUTO')
+    {
+        $this->generatedValue = $strategy;
+
+        return $this;
+    }
+
+    /**
+     * Sets field versioned.
+     *
+     * @return static
+     */
+    public function isVersionField()
+    {
+        $this->version = true;
+
+        return $this;
+    }
+
+    /**
+     * Sets Sequence Generator.
+     *
+     * @param string $sequenceName
+     * @param int    $allocationSize
+     * @param int    $initialValue
+     *
+     * @return static
+     */
+    public function setSequenceGenerator($sequenceName, $allocationSize = 1, $initialValue = 1)
+    {
+        $this->sequenceDef = [
+            'sequenceName' => $sequenceName,
+            'allocationSize' => $allocationSize,
+            'initialValue' => $initialValue,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Sets column definition.
+     *
+     * @param string $def
+     *
+     * @return static
+     */
+    public function columnDefinition($def)
+    {
+        $this->mapping['columnDefinition'] = $def;
+
+        return $this;
+    }
+
+    /**
+     * Set the FQCN of the custom ID generator.
+     * This class must extend \Doctrine\ORM\Id\AbstractIdGenerator.
+     *
+     * @param string $customIdGenerator
+     *
+     * @return $this
+     */
+    public function setCustomIdGenerator($customIdGenerator)
+    {
+        $this->customIdGenerator = (string) $customIdGenerator;
+
+        return $this;
+    }
+
+    /**
+     * Finalizes this field and attach it to the ClassMetadata.
+     *
+     * Without this call a FieldBuilder has no effect on the ClassMetadata.
+     *
+     * @return ClassMetadataBuilder
+     */
+    public function build()
+    {
+        $cm = $this->builder->getClassMetadata();
+        if ($this->generatedValue) {
+            $cm->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $this->generatedValue));
+        }
+
+        if ($this->version) {
+            $cm->setVersionMapping($this->mapping);
+        }
+
+        $cm->mapField($this->mapping);
+        if ($this->sequenceDef) {
+            $cm->setSequenceGeneratorDefinition($this->sequenceDef);
+        }
+
+        if ($this->customIdGenerator) {
+            $cm->setCustomGeneratorDefinition(['class' => $this->customIdGenerator]);
+        }
+
+        return $this->builder;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/ManyToManyAssociationBuilder.php

@@ -0,0 +1,101 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+/**
+ * ManyToMany Association Builder
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.com
+ * @since       2.0
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class ManyToManyAssociationBuilder extends OneToManyAssociationBuilder
+{
+    /**
+     * @var string|null
+     */
+    private $joinTableName;
+
+    /**
+     * @var array
+     */
+    private $inverseJoinColumns = [];
+
+    /**
+     * @param string $name
+     *
+     * @return static
+     */
+    public function setJoinTable($name)
+    {
+        $this->joinTableName = $name;
+
+        return $this;
+    }
+
+    /**
+     * Adds Inverse Join Columns.
+     *
+     * @param string      $columnName
+     * @param string      $referencedColumnName
+     * @param bool        $nullable
+     * @param bool        $unique
+     * @param string|null $onDelete
+     * @param string|null $columnDef
+     *
+     * @return static
+     */
+    public function addInverseJoinColumn($columnName, $referencedColumnName, $nullable = true, $unique = false, $onDelete = null, $columnDef = null)
+    {
+        $this->inverseJoinColumns[] = [
+            'name' => $columnName,
+            'referencedColumnName' => $referencedColumnName,
+            'nullable' => $nullable,
+            'unique' => $unique,
+            'onDelete' => $onDelete,
+            'columnDefinition' => $columnDef,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * @return ClassMetadataBuilder
+     */
+    public function build()
+    {
+        $mapping = $this->mapping;
+        $mapping['joinTable'] = [];
+        if ($this->joinColumns) {
+            $mapping['joinTable']['joinColumns'] = $this->joinColumns;
+        }
+        if ($this->inverseJoinColumns) {
+            $mapping['joinTable']['inverseJoinColumns'] = $this->inverseJoinColumns;
+        }
+        if ($this->joinTableName) {
+            $mapping['joinTable']['name'] = $this->joinTableName;
+        }
+        $cm = $this->builder->getClassMetadata();
+        $cm->mapManyToMany($mapping);
+
+        return $this->builder;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Builder/OneToManyAssociationBuilder.php

@@ -0,0 +1,70 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping\Builder;
+
+/**
+ * OneToMany Association Builder
+ *
+ * @license     http://www.opensource.org/licenses/mit-license.php MIT
+ * @link        www.doctrine-project.com
+ * @since       2.0
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class OneToManyAssociationBuilder extends AssociationBuilder
+{
+    /**
+     * @param array $fieldNames
+     *
+     * @return static
+     */
+    public function setOrderBy(array $fieldNames)
+    {
+        $this->mapping['orderBy'] = $fieldNames;
+
+        return $this;
+    }
+
+    /**
+     * @param string $fieldName
+     *
+     * @return static
+     */
+    public function setIndexBy($fieldName)
+    {
+        $this->mapping['indexBy'] = $fieldName;
+
+        return $this;
+    }
+
+    /**
+     * @return ClassMetadataBuilder
+     */
+    public function build()
+    {
+        $mapping = $this->mapping;
+        if ($this->joinColumns) {
+            $mapping['joinColumns'] = $this->joinColumns;
+        }
+        $cm = $this->builder->getClassMetadata();
+        $cm->mapOneToMany($mapping);
+
+        return $this->builder;
+    }
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Cache.php

@@ -0,0 +1,44 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * Caching to an entity or a collection.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.5
+ *
+ * @Annotation
+ * @Target({"CLASS","PROPERTY"})
+ */
+final class Cache implements Annotation
+{
+    /**
+     * @Enum({"READ_ONLY", "NONSTRICT_READ_WRITE", "READ_WRITE"})
+     * 
+     * @var string The concurrency strategy.
+     */
+    public $usage = 'READ_ONLY';
+
+    /**
+     * @var string Cache region name.
+     */
+    public $region;
+}

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/ChangeTrackingPolicy.php

@@ -0,0 +1,36 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class ChangeTrackingPolicy implements Annotation
+{
+    /**
+     * The change tracking policy.
+     *
+     * @var string
+     *
+     * @Enum({"DEFERRED_IMPLICIT", "DEFERRED_EXPLICIT", "NOTIFY"})
+     */
+    public $value;
+}