allow to define results for EnumMap::key() and EnumMap::current()

Author: marc-mabe

src/MabeEnum/EnumMap.php

@@ -8,7 +8,20 @@
 class EnumMap extends SplObjectStorage
 {
 
-    public function __construct($enumClass)
+    const KEY_AS_INDEX   = 1;
+    const KEY_AS_NAME    = 2;
+    const KEY_AS_VALUE   = 3;
+    const KEY_AS_ORDINAL = 4;
+    const CURRENT_AS_ENUM    = 8;
+    const CURRENT_AS_DATA    = 16;
+    const CURRENT_AS_NAME    = 24;
+    const CURRENT_AS_VALUE   = 56;
+    const CURRENT_AS_ORDINAL = 120;
+
+    private $enumClass;
+    private $flags;
+
+    public function __construct($enumClass, $flags = null)
     {
         if (!is_subclass_of($enumClass, __NAMESPACE__ . '\Enum')) {
             throw new InvalidArgumentException(sprintf(
@@ -17,6 +30,42 @@ public function __construct($enumClass)
             ));
         }
         $this->enumClass = $enumClass;
+
+        if ($flags === null) {
+            $flags = self::KEY_AS_INDEX | self::CURRENT_AS_ENUM;
+        }
+        $this->setFlags($flags);
+    }
+
+    public function getEnumClass()
+    {
+        return $this->enumClass;
+    }
+
+    public function setFlags($flags)
+    {
+        $flags = (int)$flags;
+
+        $keyFlags = $flags & 7;
+        if ($keyFlags < 1 || $keyFlags > 4) {
+            throw new InvalidArgumentException(
+                "Flags have to contain one of the 'KEY_AS_*' constants"
+            );
+        }
+
+        $currentFlags = $flags & 120;
+        if ($currentFlags < 8 || $currentFlags > 120) {
+            throw new InvalidArgumentException(
+                "Flags have to contain one of the 'CURRENT_AS_*' constants"
+            );
+        }
+
+        $this->flags = $flags;
+    }
+
+    public function getFlags()
+    {
+        return $this->flags;
     }
 
     public function attach($enum, $data = null)
@@ -89,4 +138,38 @@ private function initEnum(&$enum)
             $this->enumClass
         ));
     }
+
+    public function current()
+    {
+        switch ($this->flags & 120) {
+            case self::CURRENT_AS_ENUM:
+                return parent::current();
+            case self::CURRENT_AS_DATA:
+                return parent::getInfo();
+            case self::CURRENT_AS_VALUE:
+                return parent::current()->getValue();
+            default:
+                throw new RuntimeException(
+                    'Invalid current flags'
+                );
+        }
+    }
+
+    public function key()
+    {
+        switch ($this->flags & 7) {
+            case self::KEY_AS_INDEX:
+                return parent::key();
+            case self::KEY_AS_NAME:
+                return parent::current()->getName();
+            case self::KEY_AS_VALUE:
+                return parent::current()->getValue();
+            case self::KEY_AS_ORDINAL:
+                return parent::current()->getOrdinal();
+            default:
+                throw new RuntimeException(
+                    'Invalid key flags'
+                );
+        }
+    }
 }

tests/MabeEnumTest/EnumMapTest.php

@@ -81,32 +81,36 @@ public function testIterate()
         $value2 = 'value2';
 
         // an empty enum map needs to be invalid, starting by 0
+        $enumMap->rewind();
         $this->assertSame(0, $enumMap->count());
         $this->assertFalse($enumMap->valid());
 
-        // attach in revert order shouldn't change ordering of iteration
-        $enumMap->attach($enum2, $value2);
-        $enumMap->attach($enum1, $value1);
+        // attach
+        $enumMap->attach($enum1, $value2);
+        $enumMap->attach($enum2, $value1);
 
         // a not empty enum map should be valid, starting by 0 (if not iterated)
+        $enumMap->rewind();
         $this->assertSame(2, $enumMap->count());
         $this->assertTrue($enumMap->valid());
-        $this->assertSame(0, $enumMap->currentPosition());
-        $this->assertSame($enum1, $enumMap->key());
-        $this->assertSame($value1, $enumMap->current());
+        $this->assertSame(0, $enumMap->key());
+        $this->assertSame($enum1, $enumMap->current());
 
         // go to the next element (last)
         $this->assertNull($enumMap->next());
         $this->assertTrue($enumMap->valid());
-        $this->assertSame(1, $enumMap->currentPosition());
-        $this->assertSame($enum2, $enumMap->key());
-        $this->assertSame($value2, $enumMap->current());
+        $this->assertSame(1, $enumMap->key());
+        $this->assertSame($enum2, $enumMap->current());
 
         // go to the next element (out of range)
         $this->assertNull($enumMap->next());
         $this->assertFalse($enumMap->valid());
-        $this->assertSame(2, $enumMap->currentPosition());
-        //$this->assertSame($enum2, $enumMap->currentEnum());
-        //$this->assertSame($value2, $enumMap->currentValue());
+        $this->assertSame(2, $enumMap->key());
+
+        // rewind will set the iterator position back to 0
+        $enumMap->rewind();
+        $this->assertTrue($enumMap->valid());
+        $this->assertSame(0, $enumMap->key());
+        $this->assertSame($enum1, $enumMap->current());
     }
 }