Configuration - Code Metrics - Inspection of "Replace proxy layer with ProxyManager's layer" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — develop (#6719)

by Marco

created 2017-09-23 18:46 UTC

Configuration F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	860
Duplicated Lines	3.72 %

Coupling/Cohesion

Components	2
Dependencies	16

Test Coverage

Coverage

97.35%

Importance

Changes

Metric	Value
wmc	98
lcom	2
cbo	16
dl	32
loc	860
ccs	220
cts	226
cp	0.9735
rs	1.263
c	0
b	0
f	0

58 Methods

Rating	Name	Duplication	Size	Complexity
A	getAutoGenerateProxyClasses()	0	6	2
A	getProxyDir()	0	6	2
B	setAutoGenerateProxyClasses()	0	22	5
A	getProxyNamespace()	0	6	2
A	setProxyNamespace()	0	6	1
A	setMetadataDriverImpl()	0	4	1
A	newDefaultAnnotationDriver()	8	8	1
A	addEntityNamespace()	0	4	1
A	getEntityNamespace()	0	8	2
A	setEntityNamespaces()	0	4	1
A	getEntityNamespaces()	0	4	1
A	getMetadataDriverImpl()	0	6	2
A	getQueryCacheImpl()	0	6	2
A	setQueryCacheImpl()	0	4	1
A	getHydrationCacheImpl()	0	6	2
A	setHydrationCacheImpl()	0	4	1
A	getMetadataCacheImpl()	0	6	2
A	setMetadataCacheImpl()	0	4	1
A	addNamedQuery()	0	4	1
A	getNamedQuery()	0	8	2
A	addNamedNativeQuery()	0	4	1
A	getNamedNativeQuery()	0	8	2
B	ensureProductionSettings()	0	26	6
A	addCustomStringFunction()	0	4	1
A	getCustomStringFunction()	8	8	2
A	setCustomStringFunctions()	0	6	2
A	addCustomNumericFunction()	0	4	1
A	getCustomNumericFunction()	8	8	2
A	setCustomNumericFunctions()	0	6	2
A	addCustomDatetimeFunction()	0	4	1
A	getCustomDatetimeFunction()	8	8	2
A	setCustomDatetimeFunctions()	0	6	2
A	setCustomHydrationModes()	0	8	2
A	getCustomHydrationMode()	0	6	2
A	addCustomHydrationMode()	0	4	1
A	setClassMetadataFactoryName()	0	4	1
A	getClassMetadataFactoryName()	0	8	2
A	addFilter()	0	4	1
A	getFilterClassName()	0	6	2
A	setDefaultRepositoryClassName()	0	10	2
A	getDefaultRepositoryClassName()	0	6	2
A	setNamingStrategy()	0	4	1
A	getNamingStrategy()	0	8	2
A	setEntityListenerResolver()	0	4	1
A	getEntityListenerResolver()	0	8	2
A	setRepositoryFactory()	0	4	1
A	getRepositoryFactory()	0	6	2
A	isSecondLevelCacheEnabled()	0	6	2
A	setSecondLevelCacheEnabled()	0	4	1
A	setSecondLevelCacheConfiguration()	0	4	1
A	getSecondLevelCacheConfiguration()	0	10	4
A	getDefaultQueryHints()	0	4	2
A	setDefaultQueryHints()	0	4	1
A	getDefaultQueryHint()	0	6	2
A	setDefaultQueryHint()	0	4	1
A	buildGhostObjectFactory()	0	4	1
A	getProxyManagerConfiguration()	0	5	1
A	setProxyDir()	0	7	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Configuration often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Configuration, and based on these observations, apply Extract Interface, too.

<?php

declare(strict_types=1);

namespace Doctrine\ORM;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\Cache as CacheDriver;
use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\ORM\Cache\CacheConfiguration;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Mapping\DefaultEntityListenerResolver;
use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
use Doctrine\ORM\Mapping\Driver\MappingDriver;
use Doctrine\ORM\Mapping\EntityListenerResolver;
use Doctrine\ORM\Mapping\Factory\DefaultNamingStrategy;
use Doctrine\ORM\Mapping\Factory\NamingStrategy;
use Doctrine\ORM\Proxy\Factory\ProxyFactory;
use Doctrine\ORM\Repository\DefaultRepositoryFactory;
use Doctrine\ORM\Repository\RepositoryFactory;
use ProxyManager\Configuration as ProxyManagerConfiguration;
use ProxyManager\Factory\LazyLoadingGhostFactory;
use ProxyManager\FileLocator\FileLocator;
use ProxyManager\GeneratorStrategy\EvaluatingGeneratorStrategy;
use ProxyManager\GeneratorStrategy\FileWriterGeneratorStrategy;

/**
 * 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 <[email protected]>
 * @author  Guilherme Blanco <[email protected]>
 * @author  Jonathan Wage <[email protected]>
 * @author  Roman Borschel <[email protected]>
 */
class Configuration extends \Doctrine\DBAL\Configuration
{
    /**
     * @var ProxyManagerConfiguration|null
     */
    private $proxyManagerConfiguration;

    /**
     * Sets the directory where Doctrine generates any necessary proxy class files.
     *
     * @param string $dir
     *
     * @return void
     */
    public function setProxyDir($dir)
    {
        $this->attributes['proxyDir'] = $dir;


        $this->getProxyManagerConfiguration()->setProxiesTargetDir($dir);
        $this->setAutoGenerateProxyClasses(ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS);
    }

    /**
     * Gets the directory where Doctrine generates any necessary proxy class files.
     *
     * @return string|null
     *
     * @deprecated please do not use this anymore
     */
    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\ORM\Proxy\Factory\ProxyFactory.
     *
     * @deprecated please do not use this anymore
     */
    public function getAutoGenerateProxyClasses()
    {
        return isset($this->attributes['autoGenerateProxyClasses'])

            ? $this->attributes['autoGenerateProxyClasses']

            : ProxyFactory::AUTOGENERATE_ALWAYS;
    }

    /**
     * Sets the strategy for automatically generating proxy classes.
     *
     * @param boolean|int $autoGenerate Possible values are constants of Doctrine\ORM\Proxy\Factory\ProxyFactory.
     *                                  True is converted to AUTOGENERATE_ALWAYS, false to AUTOGENERATE_NEVER.
     *
     * @return void
     */
    public function setAutoGenerateProxyClasses($autoGenerate)
    {
        $this->attributes['autoGenerateProxyClasses'] = (int) $autoGenerate;


        $proxyManagerConfig = $this->getProxyManagerConfiguration();

        switch ((int) $autoGenerate) {
            case ProxyFactory::AUTOGENERATE_ALWAYS:
            case ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS:
                $proxyManagerConfig->setGeneratorStrategy(new FileWriterGeneratorStrategy(
                    new FileLocator($proxyManagerConfig->getProxiesTargetDir())
                ));

                return;
            case ProxyFactory::AUTOGENERATE_NEVER:
            case ProxyFactory::AUTOGENERATE_EVAL:
            default:
                $proxyManagerConfig->setGeneratorStrategy(new EvaluatingGeneratorStrategy());

                return;
        }
    }

    /**
     * Gets the namespace where proxy classes reside.
     *
     * @return string|null
     *
     * @deprecated please do not use this anymore
     */
    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;


        $this->getProxyManagerConfiguration()->setProxiesNamespace($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.
     *
     * @param array $paths
     *
     * @return AnnotationDriver
     */
    public function newDefaultAnnotationDriver($paths = [])
    {
        AnnotationRegistry::registerFile(__DIR__ . '/Annotation/DoctrineAnnotations.php');


        $reader = new CachedReader(new AnnotationReader(), new ArrayCache());

        return new AnnotationDriver($reader, (array) $paths);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * 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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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.
     */
    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
     */
    public function setClassMetadataFactoryName($cmfName)
    {
        $this->attributes['classMetadataFactoryName'] = $cmfName;

    }

    /**
     * @return 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 The class name of the filter, or null if it is not
     *  defined.
     */
    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 not is a \Doctrine\Common\Persistence\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
     */
    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'];

    }

    /**
     * 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;

    }

    public function buildGhostObjectFactory() : LazyLoadingGhostFactory
    {
        return new LazyLoadingGhostFactory(clone $this->getProxyManagerConfiguration());
    }

    public function getProxyManagerConfiguration() : ProxyManagerConfiguration
    {
        return $this->proxyManagerConfiguration
            ?? $this->proxyManagerConfiguration = new ProxyManagerConfiguration();
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\ORM;
6
7			use Doctrine\Common\Annotations\AnnotationReader;
8			use Doctrine\Common\Annotations\AnnotationRegistry;
9			use Doctrine\Common\Annotations\CachedReader;
10			use Doctrine\Common\Cache\ArrayCache;
11			use Doctrine\Common\Cache\Cache as CacheDriver;
12			use Doctrine\Common\Persistence\ObjectRepository;
13			use Doctrine\ORM\Cache\CacheConfiguration;
14			use Doctrine\ORM\Mapping\ClassMetadataFactory;
15			use Doctrine\ORM\Mapping\DefaultEntityListenerResolver;
16			use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
17			use Doctrine\ORM\Mapping\Driver\MappingDriver;
18			use Doctrine\ORM\Mapping\EntityListenerResolver;
19			use Doctrine\ORM\Mapping\Factory\DefaultNamingStrategy;
20			use Doctrine\ORM\Mapping\Factory\NamingStrategy;
21			use Doctrine\ORM\Proxy\Factory\ProxyFactory;
22			use Doctrine\ORM\Repository\DefaultRepositoryFactory;
23			use Doctrine\ORM\Repository\RepositoryFactory;
24			use ProxyManager\Configuration as ProxyManagerConfiguration;
25			use ProxyManager\Factory\LazyLoadingGhostFactory;
26			use ProxyManager\FileLocator\FileLocator;
27			use ProxyManager\GeneratorStrategy\EvaluatingGeneratorStrategy;
28			use ProxyManager\GeneratorStrategy\FileWriterGeneratorStrategy;
29
30			/**
31			* Configuration container for all configuration options of Doctrine.
32			* It combines all configuration options from DBAL & ORM.
33			*
34			* Internal note: When adding a new configuration option just write a getter/setter pair.
35			*
36			* @since 2.0
37			* @author Benjamin Eberlei <[email protected]>
38			* @author Guilherme Blanco <[email protected]>
39			* @author Jonathan Wage <[email protected]>
40			* @author Roman Borschel <[email protected]>

doctrine / orm