Optimized Enum::getConstants()

Author: marc-mabe

src/Enum.php

@@ -130,9 +130,10 @@ final public function getName()
     final public function getOrdinal()
     {
         if ($this->ordinal === null) {
-            $ordinal = 0;
-            $value   = $this->value;
-            foreach (self::detectConstants(static::class) as $constValue) {
+            $ordinal   = 0;
+            $value     = $this->value;
+            $constants = self::$constants[static::class] ?? static::getConstants();
+            foreach ($constants as $constValue) {
                 if ($value === $constValue) {
                     break;
                 }
@@ -189,8 +190,7 @@ final public static function get($enumerator)
      */
     final public static function byValue($value)
     {
-        $constants = self::$constants[static::class]
-            ?? self::detectConstants(static::class);
+        $constants = self::$constants[static::class] ?? static::getConstants();
 
         $name = \array_search($value, $constants, true);
         if ($name === false) {
@@ -239,7 +239,7 @@ final public static function byName(string $name)
      */
     final public static function byOrdinal(int $ordinal)
     {
-        $constants = self::$constants[static::class] ?? self::detectConstants(static::class);
+        $constants = self::$constants[static::class] ?? static::getConstants();
 
         if (!isset(self::$names[static::class][$ordinal])) {
             throw new InvalidArgumentException(\sprintf(
@@ -262,7 +262,7 @@ final public static function byOrdinal(int $ordinal)
     final public static function getEnumerators()
     {
         if (!isset(self::$names[static::class])) {
-            self::detectConstants(static::class);
+            static::getConstants();
         }
         return \array_map([static::class, 'byName'], self::$names[static::class]);
     }
@@ -274,7 +274,7 @@ final public static function getEnumerators()
      */
     final public static function getValues()
     {
-        return \array_values(self::detectConstants(static::class));
+        return \array_values(self::$constants[static::class] ?? static::getConstants());
     }
 
     /**
@@ -285,7 +285,7 @@ final public static function getValues()
     final public static function getNames()
     {
         if (!isset(self::$names[static::class])) {
-            self::detectConstants(static::class);
+            static::getConstants();
         }
         return self::$names[static::class];
     }
@@ -297,7 +297,7 @@ final public static function getNames()
      */
     final public static function getOrdinals()
     {
-        $count = \count(self::detectConstants(static::class));
+        $count = \count(self::$constants[static::class] ?? static::getConstants());
         return $count ? \range(0, $count - 1) : [];
     }
 
@@ -309,7 +309,49 @@ final public static function getOrdinals()
      */
     final public static function getConstants()
     {
-        return self::detectConstants(static::class);
+        if (isset(self::$constants[static::class])) {
+            return self::$constants[static::class];
+        }
+
+        $reflection = new ReflectionClass(static::class);
+        $constants  = [];
+
+        do {
+            $scopeConstants = [];
+            // Enumerators must be defined as public class constants
+            foreach ($reflection->getReflectionConstants() as $reflConstant) {
+                if ($reflConstant->isPublic()) {
+                    $scopeConstants[ $reflConstant->getName() ] = $reflConstant->getValue();
+                }
+            }
+
+            $constants = $scopeConstants + $constants;
+        } while (($reflection = $reflection->getParentClass()) && $reflection->name !== __CLASS__);
+
+        assert(
+            self::noAmbiguousValues($constants),
+            'Ambiguous enumerator values detected for ' . static::class
+        );
+
+        self::$names[static::class] = \array_keys($constants);
+        return self::$constants[static::class] = $constants;
+    }
+
+    /**
+     * Test that the given constants does not contain ambiguous values
+     * @param array $constants
+     * @return bool
+     */
+    private static function noAmbiguousValues($constants)
+    {
+        foreach ($constants as $value) {
+            $names = \array_keys($constants, $value, true);
+            if (\count($names) > 1) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
@@ -332,8 +374,7 @@ final public static function has($enumerator)
      */
     final public static function hasValue($value)
     {
-        $constants = self::detectConstants(static::class);
-        return \in_array($value, $constants, true);
+        return \in_array($value, self::$constants[static::class] ?? static::getConstants(), true);
     }
 
     /**
@@ -347,59 +388,6 @@ final public static function hasName(string $name)
         return \defined("static::{$name}");
     }
 
-    /**
-     * Detect all public available constants of given enumeration class
-     *
-     * @param string $class
-     * @return array
-     */
-    private static function detectConstants($class)
-    {
-        if (!isset(self::$constants[$class])) {
-            $reflection = new ReflectionClass($class);
-            $constants  = [];
-
-            do {
-                $scopeConstants = [];
-                // Enumerators must be defined as public class constants
-                foreach ($reflection->getReflectionConstants() as $reflConstant) {
-                    if ($reflConstant->isPublic()) {
-                        $scopeConstants[ $reflConstant->getName() ] = $reflConstant->getValue();
-                    }
-                }
-
-                $constants = $scopeConstants + $constants;
-            } while (($reflection = $reflection->getParentClass()) && $reflection->name !== __CLASS__);
-
-            assert(
-                self::noAmbiguousValues($constants),
-                "Ambiguous enumerator values detected for {$class}"
-            );
-
-            self::$constants[$class] = $constants;
-            self::$names[$class] = \array_keys($constants);
-        }
-
-        return self::$constants[$class];
-    }
-
-    /**
-     * Test that the given constants does not contain ambiguous values
-     * @param array $constants
-     * @return bool
-     */
-    private static function noAmbiguousValues($constants)
-    {
-        foreach ($constants as $value) {
-            $names = \array_keys($constants, $value, true);
-            if (\count($names) > 1) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
     /**
      * Get an enumerator instance by the given name.
      *

tests/MabeEnumTest/EnumSerializableTraitTest.php

@@ -8,6 +8,7 @@
 use MabeEnumTest\TestAsset\SerializableEnum;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
+use ReflectionProperty;
 use RuntimeException;
 
 /**
@@ -89,11 +90,9 @@ private function clearEnumeration($enumeration)
             $reflClass = $reflClass->getParentClass();
         }
 
-        $reflPropInstances = $reflClass->getProperty('instances');
-        $reflPropInstances->setAccessible(true);
-        $reflPropInstances->setValue(null, array());
-        $reflPropConstants = $reflClass->getProperty('constants');
-        $reflPropConstants->setAccessible(true);
-        $reflPropConstants->setValue(null, array());
+        foreach ($reflClass->getProperties(ReflectionProperty::IS_STATIC) as $reflProp) {
+            $reflProp->setAccessible(true);;
+            $reflProp->setValue(null, []);
+        }
     }
 }