Phpfastcache\CacheManager::getInstance()

Complexity

Conditions	15
Paths	200

Size

Total Lines	62
Code Lines	41

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public static function getInstance($driver = 'auto', $config = null, $instanceId = null)
    {
        static $badPracticeOmeter = [];

        if ($instanceId !== null && !\is_string($instanceId)) {

The condition $instanceId !== null && ! is_string($instanceId) can never be true.

            throw new phpFastCacheInvalidArgumentException('The Instance ID must be a string');
        }

        if (is_array($config)) {
            $config = new ConfigurationOption($config);
            trigger_error(
              'The CacheManager will drops the support of primitive configuration arrays, use a "\Phpfastcache\Config\ConfigurationOption" object instead',
              E_USER_DEPRECATED
            );
        }elseif ($config === null){
            $config = self::getDefaultConfig();
        }else if(!($config instanceof ConfigurationOption)){

The condition ! $config instanceof Phpfastcache\Config\ConfigurationOption can never be true.

            throw new phpFastCacheInvalidArgumentException(sprintf('Unsupported config type: %s', gettype($config)));
        }

        $driver = self::standardizeDriverName($driver);

        if (!$driver || $driver === 'Auto') {
            $driver = self::getAutoClass($config);

$config of type Phpfastcache\Config\ConfigurationOption is incompatible with the type array expected by parameter $config of Phpfastcache\CacheManager::getAutoClass().

        }

        $instance = $instanceId ?: md5($driver . \serialize($config->toArray()));

        if (!isset(self::$instances[ $instance ])) {
            $badPracticeOmeter[ $driver ] = 1;
            $driverClass = self::getNamespacePath() . $driver . '\Driver';
            try {
                if (\class_exists($driverClass)) {
                    $configClass = $driverClass::getConfigClass();
                    self::$instances[ $instance ] = new $driverClass(new $configClass($config->toArray()), $instance);
                    self::$instances[ $instance ]->setEventManager(EventManager::getInstance());
                } else {
                    throw new phpFastCacheDriverNotFoundException(sprintf('The driver "%s" does not exists', $driver));
                }
            } catch (phpFastCacheDriverCheckException $e) {
                if ($config->getFallback()) {
                    try {

                        $fallback = $config->getFallback();
                        $config->setFallback('');
                        trigger_error(sprintf('The "%s" driver is unavailable at the moment, the fallback driver "%s" has been used instead.', $driver, $fallback), E_USER_WARNING);
                        return self::getInstance($fallback, $config);
                    } catch (phpFastCacheInvalidArgumentException $e) {
                        throw new phpFastCacheInvalidConfigurationException('Invalid fallback driver configuration', 0, $e);
                    }
                } else {
                    throw new phpFastCacheDriverCheckException($e->getMessage(), $e->getCode(), $e);
                }
            }
        } else if ($badPracticeOmeter[ $driver ] >= 2) {
            trigger_error('[' . $driver . '] Calling many times CacheManager::getInstance() for already instanced drivers is a bad practice and have a significant impact on performances.
           See https://github.com/PHPSocialNetwork/phpfastcache/wiki/[V5]-Why-calling-getInstance%28%29-each-time-is-a-bad-practice-%3F');
        }

        $badPracticeOmeter[ $driver ]++;

        return self::$instances[ $instance ];
    }