Paillechat\Enum\StaticEnum

Complexity

Total Complexity

6

Size/Duplication

Total Lines	42
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	createNamedInstance()	0	12	2
A	getConstantReflection()	0	11	2
A	getConstKey()	0	4	1
A	findParentClassForConst()	0	4	1

<?php

namespace Paillechat\Enum;

abstract class StaticEnum extends Enum
{
    /** @var StaticEnum[][] */
    private static $instances = [];

    private static $constReflections = [];

    final protected static function createNamedInstance(string $name, $value)
    {
        $class = self::findParentClassForConst($name);

        $key = self::getConstKey($class, $name);

        if (!array_key_exists($key, self::$instances)) {
            self::$instances[$key] = parent::createNamedInstance($name, $value);
        }

        return self::$instances[$key];

The expression self::$instances[$key]; of type Paillechat\Enum\StaticEnum[]|Paillechat\Enum\StaticEnum adds the type Paillechat\Enum\StaticEnum[] to the return on line 22 which is incompatible with the return type of the parent method Paillechat\Enum\Enum::createNamedInstance of type Paillechat\Enum\Enum.

    }

    private static function getConstantReflection(string $class, string $name): \ReflectionClassConstant
    {
        $key = self::getConstKey($class, $name);
        if (!array_key_exists($key, self::$constReflections)) {
            $refl = self::getEnumReflection(static::class);

            self::$constReflections[$key] = $refl->getReflectionConstant($name);
        }

        return self::$constReflections[$key];
    }

    private static function getConstKey(string $class, string $name): string
    {
        return $class.'::'.$name;
    }

    private static function findParentClassForConst(string $name): string
    {
        return self::getConstantReflection(static::class, $name)->getDeclaringClass()->getName();
    }
}