Merge pull request #89 from marc-mabe/optimize_byOrdinal

Optimized Enum::byOrdinal() and Enum::getName[s]()

Author: marc-mabe

src/Enum.php

@@ -30,12 +30,19 @@ abstract class Enum
     private $ordinal;
 
     /**
-     * An array of available constants by class
+     * A map of enumerator names and values by enumeration class
      *
      * @var array ["$class" => ["$name" => $value, ...], ...]
      */
     private static $constants = array();
 
+    /**
+     * A List of of available enumerator names by enumeration class
+     *
+     * @var array ["$class" => ["$name0", ...], ...]
+     */
+    private static $names = array();
+
     /**
      * Already instantiated enumerators
      *
@@ -110,6 +117,9 @@ final public function getValue()
      */
     final public function getName()
     {
+        if ($this->ordinal !== null) {
+            return self::$names[static::class][$this->ordinal];
+        }
         return array_search($this->value, self::detectConstants(static::class), true);
     }
 
@@ -235,21 +245,25 @@ final public static function byOrdinal($ordinal)
     {
         $ordinal   = (int) $ordinal;
         $class     = static::class;
-        $constants = self::detectConstants($class);
-        $item      = array_slice($constants, $ordinal, 1, true);
-        if (empty($item)) {
+
+        if (!isset(self::$names[$class])) {
+            self::detectConstants($class);
+        }
+
+        if (!isset(self::$names[$class][$ordinal])) {
             throw new InvalidArgumentException(sprintf(
                 'Invalid ordinal number, must between 0 and %s',
-                count($constants) - 1
+                count(self::$names[$class]) - 1
             ));
         }
 
-        $name = key($item);
+        $name = self::$names[$class][$ordinal];
         if (isset(self::$instances[$class][$name])) {
             return self::$instances[$class][$name];
         }
 
-        return self::$instances[$class][$name] = new $class(current($item), $ordinal);
+        $const = $class . '::' . $name;
+        return self::$instances[$class][$name] = new $class(constant($const));
     }
 
     /**
@@ -259,7 +273,10 @@ final public static function byOrdinal($ordinal)
      */
     final public static function getEnumerators()
     {
-        return array_map([static::class, 'byName'], array_keys(self::detectConstants(static::class)));
+        if (!isset(self::$names[static::class])) {
+            self::detectConstants(static::class);
+        }
+        return array_map([static::class, 'byName'], self::$names[static::class]);
     }
 
     /**
@@ -279,7 +296,10 @@ final public static function getValues()
      */
     final public static function getNames()
     {
-        return array_keys(self::detectConstants(static::class));
+        if (!isset(self::$names[static::class])) {
+            self::detectConstants(static::class);
+        }
+        return self::$names[static::class];
     }
     /*
      * Get a list of enumerator ordinal numbers
@@ -320,7 +340,7 @@ final public static function has($value)
     }
 
     /**
-     * Detect all available constants by the given class
+     * Detect all public available constants of given enumeration class
      *
      * @param string $class
      * @return array
@@ -368,6 +388,7 @@ private static function detectConstants($class)
             }
 
             self::$constants[$class] = $constants;
+            self::$names[$class] = array_keys($constants);
         }
 
         return self::$constants[$class];

tests/MabeEnumTest/EnumTest.php

@@ -4,6 +4,7 @@
 
 use InvalidArgumentException;
 use LogicException;
+use MabeEnum\Enum;
 use MabeEnumTest\TestAsset\EnumBasic;
 use MabeEnumTest\TestAsset\EnumInheritance;
 use MabeEnumTest\TestAsset\EnumAmbiguous;
@@ -23,6 +24,23 @@
  */
 class EnumTest extends TestCase
 {
+    public function setUp()
+    {
+        $enumRefl = new ReflectionClass(Enum::class);
+
+        $constantsProp = $enumRefl->getProperty('constants');
+        $namesProp = $enumRefl->getProperty('names');
+        $instancesProp = $enumRefl->getProperty('instances');
+
+        $constantsProp->setAccessible(true);
+        $namesProp->setAccessible(true);
+        $instancesProp->setAccessible(true);
+
+        $constantsProp->setValue(null, []);
+        $namesProp->setValue(null, []);
+        $instancesProp->setValue(null, []);
+    }
+
     public function testGetNameReturnsConstantNameOfCurrentValue()
     {
         $enum = EnumBasic::get(EnumBasic::ONE);
@@ -106,7 +124,7 @@ public function testGetByExtendedInstanceOfKnownValue()
         EnumBasic::get($enum);
     }
 
-    public function testGetEnumerators()
+    public function testGetEnumeratorsConstansAlreadyDetected()
     {
         $constants   = EnumInheritance::getConstants();
         $enumerators = EnumInheritance::getEnumerators();
@@ -123,6 +141,23 @@ public function testGetEnumerators()
         }
     }
 
+    public function testGetEnumeratorsConstansNotDetected()
+    {
+        $enumerators = EnumInheritance::getEnumerators();
+        $constants   = EnumInheritance::getConstants();
+        $count       = count($enumerators);
+
+        $this->assertSame(count($constants), $count);
+        for ($i = 0; $i < $count; ++$i) {
+            $this->assertArrayHasKey($i, $enumerators);
+            $this->assertInstanceOf(EnumInheritance::class, $enumerators[$i]);
+
+            $enumerator = $enumerators[$i];
+            $this->assertArrayHasKey($enumerator->getName(), $constants);
+            $this->assertSame($constants[$enumerator->getName()], $enumerator->getValue());
+        }
+    }
+
     public function testGetValues()
     {
         $expectedValues = array_values(EnumInheritance::getConstants());
@@ -136,7 +171,7 @@ public function testGetValues()
         }
     }
 
-    public function testGetNames()
+    public function testGetNamesConstantsAlreadyDetected()
     {
         $expectedNames = array_keys(EnumInheritance::getConstants());
         $names         = EnumInheritance::getNames();
@@ -149,6 +184,19 @@ public function testGetNames()
         }
     }
 
+    public function testGetNamesConstantsNotDetected()
+    {
+        $names         = EnumInheritance::getNames();
+        $expectedNames = array_keys(EnumInheritance::getConstants());
+        $count         = count($names);
+
+        $this->assertSame(count($expectedNames), $count);
+        for ($i = 0; $i < $count; ++$i) {
+            $this->assertArrayHasKey($i, $names);
+            $this->assertSame($expectedNames[$i], $names[$i]);
+        }
+    }
+    
     public function testGetOrdinals()
     {
         $constants = EnumInheritance::getConstants();