marc-mabe /
php-enum
| Total Complexity | 53 |
| Total Lines | 389 |
| Duplicated Lines | 3.08 % |
| Coverage | 97.69% |
| Changes | 0 | ||
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:
Complex classes like Enum 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.
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 Enum, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 16 | abstract class Enum |
||
| 17 | { |
||
| 18 | /** |
||
| 19 | * The selected enumerator value |
||
| 20 | * |
||
| 21 | * @var null|bool|int|float|string |
||
| 22 | */ |
||
| 23 | private $value; |
||
| 24 | |||
| 25 | /** |
||
| 26 | * The ordinal number of the enumerator |
||
| 27 | * |
||
| 28 | * @var null|int |
||
| 29 | */ |
||
| 30 | private $ordinal; |
||
| 31 | |||
| 32 | /** |
||
| 33 | * A map of enumerator names and values by enumeration class |
||
| 34 | * |
||
| 35 | * @var array ["$class" => ["$name" => $value, ...], ...] |
||
| 36 | */ |
||
| 37 | private static $constants = []; |
||
| 38 | |||
| 39 | /** |
||
| 40 | * A List of available enumerator names by enumeration class |
||
| 41 | * |
||
| 42 | * @var array ["$class" => ["$name0", ...], ...] |
||
| 43 | */ |
||
| 44 | private static $names = []; |
||
| 45 | |||
| 46 | /** |
||
| 47 | * Already instantiated enumerators |
||
| 48 | * |
||
| 49 | * @var array ["$class" => ["$name" => $instance, ...], ...] |
||
| 50 | */ |
||
| 51 | private static $instances = []; |
||
| 52 | |||
| 53 | /** |
||
| 54 | * Constructor |
||
| 55 | * |
||
| 56 | * @param null|bool|int|float|string $value The value of the enumerator |
||
| 57 | * @param int|null $ordinal The ordinal number of the enumerator |
||
| 58 | */ |
||
| 59 | 108 | final private function __construct($value, $ordinal = null) |
|
| 60 | { |
||
| 61 | 108 | $this->value = $value; |
|
| 62 | 108 | $this->ordinal = $ordinal; |
|
| 63 | 108 | } |
|
| 64 | |||
| 65 | /** |
||
| 66 | * Get the name of the enumerator |
||
| 67 | * |
||
| 68 | * @return string |
||
| 69 | * @see getName() |
||
| 70 | */ |
||
| 71 | 3 | public function __toString() |
|
| 74 | } |
||
| 75 | |||
| 76 | /** |
||
| 77 | * @throws LogicException Enums are not cloneable |
||
| 78 | * because instances are implemented as singletons |
||
| 79 | */ |
||
| 80 | 3 | final private function __clone() |
|
| 81 | { |
||
| 82 | 3 | throw new LogicException('Enums are not cloneable'); |
|
| 83 | } |
||
| 84 | |||
| 85 | /** |
||
| 86 | * @throws LogicException Enums are not serializable |
||
| 87 | * because instances are implemented as singletons |
||
| 88 | */ |
||
| 89 | 3 | final public function __sleep() |
|
| 92 | } |
||
| 93 | |||
| 94 | /** |
||
| 95 | * @throws LogicException Enums are not serializable |
||
| 96 | * because instances are implemented as singletons |
||
| 97 | */ |
||
| 98 | 3 | final public function __wakeup() |
|
| 99 | { |
||
| 100 | 3 | throw new LogicException('Enums are not serializable'); |
|
| 101 | } |
||
| 102 | |||
| 103 | /** |
||
| 104 | * Get the value of the enumerator |
||
| 105 | * |
||
| 106 | * @return null|bool|int|float|string |
||
| 107 | */ |
||
| 108 | 69 | final public function getValue() |
|
| 109 | { |
||
| 110 | 69 | return $this->value; |
|
| 111 | } |
||
| 112 | |||
| 113 | /** |
||
| 114 | * Get the name of the enumerator |
||
| 115 | * |
||
| 116 | * @return string |
||
| 117 | */ |
||
| 118 | 24 | final public function getName() |
|
| 119 | { |
||
| 120 | 24 | $ordinal = $this->ordinal !== null ? $this->ordinal : $this->getOrdinal(); |
|
| 121 | 24 | return self::$names[static::class][$ordinal]; |
|
| 122 | } |
||
| 123 | |||
| 124 | /** |
||
| 125 | * Get the ordinal number of the enumerator |
||
| 126 | * |
||
| 127 | * @return int |
||
| 128 | */ |
||
| 129 | 189 | final public function getOrdinal() |
|
| 130 | { |
||
| 131 | 189 | if ($this->ordinal === null) { |
|
| 132 | 57 | $ordinal = 0; |
|
| 133 | 57 | $value = $this->value; |
|
| 134 | 57 | foreach (self::detectConstants(static::class) as $constValue) { |
|
| 135 | 57 | if ($value === $constValue) { |
|
| 136 | 57 | break; |
|
| 137 | } |
||
| 138 | 48 | ++$ordinal; |
|
| 139 | 19 | } |
|
| 140 | |||
| 141 | 57 | $this->ordinal = $ordinal; |
|
| 142 | 19 | } |
|
| 143 | |||
| 144 | 189 | return $this->ordinal; |
|
| 145 | } |
||
| 146 | |||
| 147 | /** |
||
| 148 | * Compare this enumerator against another and check if it's the same. |
||
| 149 | * |
||
| 150 | * @param mixed $enumerator |
||
| 151 | * @return bool |
||
| 152 | */ |
||
| 153 | 6 | final public function is($enumerator) |
|
| 154 | { |
||
| 155 | 6 | return $this === $enumerator || $this->value === $enumerator |
|
| 156 | |||
| 157 | // The following additional conditions are required only because of the issue of serializable singletons |
||
| 158 | 6 | || ($enumerator instanceof static |
|
| 159 | 6 | && \get_class($enumerator) === static::class |
|
| 160 | 6 | && $enumerator->value === $this->value |
|
| 161 | 2 | ); |
|
| 162 | } |
||
| 163 | |||
| 164 | /** |
||
| 165 | * Get an enumerator instance of the given enumerator value or instance |
||
| 166 | * |
||
| 167 | * @param static|null|bool|int|float|string $enumerator |
||
| 168 | * @return static |
||
| 169 | * @throws InvalidArgumentException On an unknwon or invalid value |
||
| 170 | * @throws LogicException On ambiguous constant values |
||
| 171 | */ |
||
| 172 | 219 | final public static function get($enumerator) |
|
| 179 | } |
||
| 180 | |||
| 181 | /** |
||
| 182 | * Get an enumerator instance by the given value |
||
| 183 | * |
||
| 184 | * @param mixed $value |
||
| 185 | * @return static |
||
| 186 | * @throws InvalidArgumentException On an unknwon or invalid value |
||
| 187 | * @throws LogicException On ambiguous constant values |
||
| 188 | */ |
||
| 189 | 156 | final public static function byValue($value) |
|
| 205 | } |
||
| 206 | |||
| 207 | /** |
||
| 208 | * Get an enumerator instance by the given name |
||
| 209 | * |
||
| 210 | * @param string $name The name of the enumerator |
||
| 211 | * @return static |
||
| 212 | * @throws InvalidArgumentException On an invalid or unknown name |
||
| 213 | * @throws LogicException On ambiguous values |
||
| 214 | */ |
||
| 215 | 132 | final public static function byName($name) |
|
| 216 | { |
||
| 217 | 132 | $name = (string) $name; |
|
| 218 | 132 | View Code Duplication | if (isset(self::$instances[static::class][$name])) { |
|
|
|||
| 219 | 96 | return self::$instances[static::class][$name]; |
|
| 220 | } |
||
| 221 | |||
| 222 | 51 | $const = static::class . '::' . $name; |
|
| 223 | 51 | if (!\defined($const)) { |
|
| 224 | 3 | throw new InvalidArgumentException($const . ' not defined'); |
|
| 225 | } |
||
| 226 | |||
| 227 | 48 | return self::$instances[static::class][$name] = new static(\constant($const)); |
|
| 228 | } |
||
| 229 | |||
| 230 | /** |
||
| 231 | * Get an enumeration instance by the given ordinal number |
||
| 232 | * |
||
| 233 | * @param int $ordinal The ordinal number or the enumerator |
||
| 234 | * @return static |
||
| 235 | * @throws InvalidArgumentException On an invalid ordinal number |
||
| 236 | * @throws LogicException On ambiguous values |
||
| 237 | */ |
||
| 238 | 90 | final public static function byOrdinal($ordinal) |
|
| 239 | { |
||
| 240 | 90 | $ordinal = (int) $ordinal; |
|
| 241 | |||
| 242 | 90 | if (!isset(self::$names[static::class])) { |
|
| 243 | 6 | self::detectConstants(static::class); |
|
| 244 | 2 | } |
|
| 245 | |||
| 246 | 90 | if (!isset(self::$names[static::class][$ordinal])) { |
|
| 247 | 3 | throw new InvalidArgumentException(\sprintf( |
|
| 248 | 3 | 'Invalid ordinal number, must between 0 and %s', |
|
| 249 | 3 | \count(self::$names[static::class]) - 1 |
|
| 250 | 1 | )); |
|
| 251 | } |
||
| 252 | |||
| 253 | 87 | $name = self::$names[static::class][$ordinal]; |
|
| 254 | 87 | View Code Duplication | if (isset(self::$instances[static::class][$name])) { |
| 255 | 81 | return self::$instances[static::class][$name]; |
|
| 256 | } |
||
| 257 | |||
| 258 | 9 | $const = static::class . '::' . $name; |
|
| 259 | 9 | return self::$instances[static::class][$name] = new static(\constant($const), $ordinal); |
|
| 260 | } |
||
| 261 | |||
| 262 | /** |
||
| 263 | * Get a list of enumerator instances ordered by ordinal number |
||
| 264 | * |
||
| 265 | * @return static[] |
||
| 266 | */ |
||
| 267 | 48 | final public static function getEnumerators() |
|
| 268 | { |
||
| 269 | 48 | if (!isset(self::$names[static::class])) { |
|
| 270 | 3 | self::detectConstants(static::class); |
|
| 271 | 1 | } |
|
| 272 | 48 | return \array_map([static::class, 'byName'], self::$names[static::class]); |
|
| 273 | } |
||
| 274 | |||
| 275 | /** |
||
| 276 | * Get a list of enumerator values ordered by ordinal number |
||
| 277 | * |
||
| 278 | * @return mixed[] |
||
| 279 | */ |
||
| 280 | 3 | final public static function getValues() |
|
| 281 | { |
||
| 282 | 3 | return \array_values(self::detectConstants(static::class)); |
|
| 283 | } |
||
| 284 | |||
| 285 | /** |
||
| 286 | * Get a list of enumerator names ordered by ordinal number |
||
| 287 | * |
||
| 288 | * @return string[] |
||
| 289 | */ |
||
| 290 | 6 | final public static function getNames() |
|
| 296 | } |
||
| 297 | /* |
||
| 298 | * Get a list of enumerator ordinal numbers |
||
| 299 | * |
||
| 300 | * @return int[] |
||
| 301 | */ |
||
| 302 | 3 | final public static function getOrdinals() |
|
| 303 | { |
||
| 304 | 3 | $count = \count(self::detectConstants(static::class)); |
|
| 305 | 3 | return $count === 0 ? [] : \range(0, $count - 1); |
|
| 306 | } |
||
| 307 | |||
| 308 | /** |
||
| 309 | * Get all available constants of the called class |
||
| 310 | * |
||
| 311 | * @return array |
||
| 312 | * @throws LogicException On ambiguous constant values |
||
| 313 | */ |
||
| 314 | 236 | final public static function getConstants() |
|
| 315 | { |
||
| 316 | 236 | return self::detectConstants(static::class); |
|
| 317 | } |
||
| 318 | |||
| 319 | /** |
||
| 320 | * Is the given enumerator part of this enumeration |
||
| 321 | * |
||
| 322 | * @param static|null|bool|int|float|string $value |
||
| 323 | * @return bool |
||
| 324 | */ |
||
| 325 | 3 | final public static function has($value) |
|
| 326 | { |
||
| 327 | 3 | if ($value instanceof static && \get_class($value) === static::class) { |
|
| 328 | 3 | return true; |
|
| 329 | } |
||
| 330 | |||
| 331 | 3 | $constants = self::detectConstants(static::class); |
|
| 332 | 3 | return \in_array($value, $constants, true); |
|
| 333 | } |
||
| 334 | |||
| 335 | /** |
||
| 336 | * Detect all public available constants of given enumeration class |
||
| 337 | * |
||
| 338 | * @param string $class |
||
| 339 | * @return array |
||
| 340 | * @throws LogicException On ambiguous constant values |
||
| 341 | */ |
||
| 342 | 308 | private static function detectConstants($class) |
|
| 388 | } |
||
| 389 | |||
| 390 | /** |
||
| 391 | * Get an enumerator instance by the given name. |
||
| 392 | * |
||
| 393 | * This will be called automatically on calling a method |
||
| 394 | * with the same name of a defined enumerator. |
||
| 395 | * |
||
| 396 | * @param string $method The name of the enumeraotr (called as method) |
||
| 397 | * @param array $args There should be no arguments |
||
| 398 | * @return static |
||
| 399 | * @throws InvalidArgumentException On an invalid or unknown name |
||
| 400 | * @throws LogicException On ambiguous constant values |
||
| 401 | */ |
||
| 402 | 78 | final public static function __callStatic($method, array $args) |
|
| 405 | } |
||
| 406 | } |
||
| 407 |
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.