fixes #32: implemented EnumSet in base of a real BitSet

Author: marc-mabe

README.md

@@ -125,6 +125,7 @@ corresponding instance of `UserStatus` else an exception will be thrown.)
 ## EnumMap
 
 An ```EnumMap``` maps enumerators of the same type to data assigned to.
+
 Internally the ```EnumMap``` is based of ```SplObjectStorage```.
 
     use MabeEnum\EnumMap;
@@ -145,14 +146,19 @@ Internally the ```EnumMap``` is based of ```SplObjectStorage```.
     var_dump(iterator_to_array($enumSet)); // array(0 => UserStatus{$value=1});
 
     // define key and value used for iteration
-    $enumSet->setFlags(EnumSet::KEY_AS_NAME | EnumSet::CURRENT_AS_DATA);
+    $enumSet->setFlags(EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_DATA);
     var_dump(iterator_to_array($enumSet)); // array('ACTIVE' => 'aktiv');
 
 
 ## EnumSet
 
-An ```EnumSet``` groups enumerators of the same type together.
-Internally it's based of a list (array) of ordinal values.
+An ```EnumSet``` groups enumerators of the same enumeration type together.
+
+Internally it's based of an integer bit set.
+
+The maximun number of enumerators are limited by the size of an integer.
+
+Enumerators will be ordered by the ordinal number.
 
     use MabeEnum\EnumSet;
 

src/MabeEnum/EnumSet.php

@@ -5,9 +5,10 @@
 use Iterator;
 use Countable;
 use InvalidArgumentException;
+use OutOfRangeException;
 
 /**
- * EnumSet implementation in base of an array
+ * EnumSet implementation in base of an integer bit set
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2015 Marc Bennewitz
@@ -16,59 +17,60 @@
 class EnumSet implements Iterator, Countable
 {
     /**
-     * Flag for a unique set of enumerators
-     */
-    const UNIQUE  = 1;
-
-    /**
-     * Flag for an ordered set of enumerators by ordinal
-     */
-    const ORDERED = 2;
-
-    /**
+     * Enumeration class
      * @var string
      */
     private $enumClass;
 
     /**
-     * @var array
+     * BitSet of all attached enumerations
+     * @var int
      */
-    private $list      = array();
+    private $bitset = 0;
 
     /**
+     * Ordinal number of current iterator position
      * @var int
      */
-    private $index     = 0;
+    private $ordinal = 0;
 
     /**
+     * Highest possible ordinal number
      * @var int
      */
-    private $flags     = self::UNIQUE;
+    private $ordinalMax = 0;
 
     /**
      * Constructor
      *
-     * @param string   $enumClass The classname of an enumeration the set is for
-     * @param null|int $flags     Flags to define behaviours
+     * @param string $enumClass Classname of an enumeration the set is for
      * @throws InvalidArgumentException
      */
-    public function __construct($enumClass, $flags = null)
+    public function __construct($enumClass)
     {
         if (!is_subclass_of($enumClass, __NAMESPACE__ . '\Enum')) {
             throw new InvalidArgumentException(sprintf(
                 "This EnumSet can handle subclasses of '%s' only",
                 __NAMESPACE__ . '\Enum'
             ));
         }
-        $this->enumClass = $enumClass;
 
-        if ($flags !== null) {
-            $this->flags = (int) $flags;
+        $this->enumClass  = $enumClass;
+        $this->ordinalMax = count($enumClass::getConstants());
+
+        if (PHP_INT_SIZE * 8 < $this->ordinalMax) {
+            throw new OutOfRangeException(sprintf(
+                "Your system can handle up to %u enumeration values within an EnumSet"
+                . " but the given enumeration class '%s' has defined %u enumeration values",
+                PHP_INT_SIZE * 8,
+                $enumClass,
+                $this->ordinalMax
+            ));
         }
     }
 
     /**
-     * Get the classname of the enumeration this set is for
+     * Get the classname of enumeration this set is for
      * @return string
      */
     public function getEnumClass()
@@ -77,108 +79,119 @@ public function getEnumClass()
     }
 
     /**
-     * Get flags of defined behaviours
-     * @return int
-     */
-    public function getFlags()
-    {
-        return $this->flags;
-    }
-
-    /**
-     * Attach a new enumerator or overwrite an existing one
+     * Attach a new enumeration or overwrite an existing one
      * @param Enum|null|boolean|int|float|string $enum
      * @return void
      * @throws InvalidArgumentException On an invalid given enum
      */
     public function attach($enum)
     {
         $enumClass = $this->enumClass;
-        $ordinal   = $enumClass::get($enum)->getOrdinal();
-
-        if (!($this->flags & self::UNIQUE) || !in_array($ordinal, $this->list, true)) {
-            $this->list[] = $ordinal;
-
-            if ($this->flags & self::ORDERED) {
-                sort($this->list);
-            }
-        }
+        $this->bitset |= 1 << $enumClass::get($enum)->getOrdinal();
     }
 
     /**
-     * Test if the given enumerator exists
+     * Detach all enumerations same as the given enum
      * @param Enum|null|boolean|int|float|string $enum
-     * @return boolean
+     * @return void
+     * @throws InvalidArgumentException On an invalid given enum
      */
-    public function contains($enum)
+    public function detach($enum)
     {
         $enumClass = $this->enumClass;
-        return in_array($enumClass::get($enum)->getOrdinal(), $this->list, true);
+        $this->bitset &= ~(1 << $enumClass::get($enum)->getOrdinal());
     }
 
     /**
-     * Detach all enumerators same as the given enumerator
+     * Test if the given enumeration exists
      * @param Enum|null|boolean|int|float|string $enum
-     * @return void
-     * @throws InvalidArgumentException On an invalid given enum
+     * @return boolean
      */
-    public function detach($enum)
+    public function contains($enum)
     {
         $enumClass = $this->enumClass;
-        $ordinal   = $enumClass::get($enum)->getOrdinal();
-
-        while (($index = array_search($ordinal, $this->list, true)) !== false) {
-            unset($this->list[$index]);
-        }
-
-        // reset index positions to have a real list
-        $this->list = array_values($this->list);
+        return (bool)($this->bitset & (1 << $enumClass::get($enum)->getOrdinal()));
     }
 
     /* Iterator */
 
     /**
-     * Get the current enumerator
-     * @return Enum|null Returns the current enumerator or NULL on an invalid iterator position
+     * Get current Enum
+     * @return Enum|null Returns current Enum or NULL on an invalid iterator position
      */
     public function current()
     {
-        if (!isset($this->list[$this->index])) {
-            return null;
+        if ($this->valid()) {
+            $enumClass = $this->enumClass;
+            return $enumClass::getByOrdinal($this->ordinal);
         }
 
-        $enumClass = $this->enumClass;
-        return $enumClass::getByOrdinal($this->list[$this->index]);
+        return null;
     }
 
     /**
-     * Get the current iterator position
+     * Get ordinal number of current iterator position
      * @return int
      */
     public function key()
     {
-        return $this->index;
+        return $this->ordinal;
     }
 
+    /**
+     * Go to the next iterator position
+     * @return void
+     */
     public function next()
     {
-        ++$this->index;
+        if ($this->ordinal !== $this->ordinalMax) {
+            do {
+                if (++$this->ordinal === $this->ordinalMax) {
+                    return;
+                }
+            } while (!($this->bitset & (1 << $this->ordinal)));
+        }
     }
 
+    /**
+     * Go to the first iterator position
+     * @return void
+     */
     public function rewind()
     {
-        $this->index = 0;
+        $this->ordinal = -1;
+        do {
+            if (++$this->ordinal === $this->ordinalMax) {
+                return;
+            }
+        } while (!($this->bitset & (1 << $this->ordinal)));
     }
 
+    /**
+     * Test if the iterator in a valid state
+     * @return boolean
+     */
     public function valid()
     {
-        return isset($this->list[$this->index]);
+        return $this->bitset & (1 << $this->ordinal) && $this->ordinal !== $this->ordinalMax;
     }
 
     /* Countable */
 
+    /**
+     * Count the number of elements
+     * @return int
+     */
     public function count()
     {
-        return count($this->list);
+        $cnt = 0;
+        $ord = 0;
+        do {
+            if ($this->bitset & (1 << $ord++)) {
+                ++$cnt;
+            }
+        } while ($ord !== $this->ordinalMax);
+
+        return $cnt;
     }
 }