Merge pull request #51 from TuxCoder/master-bitset

Dynamic BitSet size, Getter Setter for BitSet

Author: marc-mabe

src/EnumSet.php

@@ -5,7 +5,6 @@
 use Iterator;
 use Countable;
 use InvalidArgumentException;
-use OutOfRangeException;
 
 /**
  * EnumSet implementation in base of an integer bit set
@@ -23,10 +22,10 @@ class EnumSet implements Iterator, Countable
     private $enumeration;
 
     /**
-     * BitSet of all attached enumerations
-     * @var int
+     * BitSet of all attached enumerations in little endian
+     * @var string
      */
-    private $bitset = 0;
+    private $bitset;
 
     /**
      * Ordinal number of current iterator position
@@ -54,19 +53,12 @@ public function __construct($enumeration)
                 __NAMESPACE__ . '\Enum'
             ));
         }
-
+        
         $this->enumeration = $enumeration;
         $this->ordinalMax  = count($enumeration::getConstants());
-
-        if (PHP_INT_SIZE * 8 < $this->ordinalMax) {
-            throw new OutOfRangeException(sprintf(
-                "Your system can handle up to %u enumerators within an EnumSet"
-                . " but the given enumeration '%s' has defined %u enumerators",
-                PHP_INT_SIZE * 8,
-                $enumeration,
-                $this->ordinalMax
-            ));
-        }
+        
+        // init the bitset with zeros
+        $this->bitset = str_repeat("\0", ceil($this->ordinalMax / 8));
     }
 
     /**
@@ -97,7 +89,7 @@ public function getEnumeration()
     public function attach($enumerator)
     {
         $enumeration = $this->enumeration;
-        $this->bitset |= 1 << $enumeration::get($enumerator)->getOrdinal();
+        $this->setBit($enumeration::get($enumerator)->getOrdinal());
     }
 
     /**
@@ -109,7 +101,7 @@ public function attach($enumerator)
     public function detach($enumerator)
     {
         $enumeration = $this->enumeration;
-        $this->bitset &= ~(1 << $enumeration::get($enumerator)->getOrdinal());
+        $this->unsetBit($enumeration::get($enumerator)->getOrdinal());
     }
 
     /**
@@ -120,7 +112,7 @@ public function detach($enumerator)
     public function contains($enumerator)
     {
         $enumeration = $this->enumeration;
-        return (bool)($this->bitset & (1 << $enumeration::get($enumerator)->getOrdinal()));
+        return $this->getBit($enumeration::get($enumerator)->getOrdinal());
     }
 
     /* Iterator */
@@ -156,11 +148,11 @@ public function key()
     public function next()
     {
         do {
-            if (++$this->ordinal >= $this->ordinalMax) {
+            if (++ $this->ordinal >= $this->ordinalMax) {
                 $this->ordinal = $this->ordinalMax;
                 return;
             }
-        } while (!($this->bitset & (1 << $this->ordinal)));
+        } while (!$this->getBit($this->ordinal));
     }
 
     /**
@@ -170,7 +162,7 @@ public function next()
      */
     public function rewind()
     {
-        if ($this->bitset) {
+        if (trim($this->bitset, "\0") !== '') {
             $this->ordinal = -1;
             $this->next();
         } else {
@@ -184,7 +176,7 @@ public function rewind()
      */
     public function valid()
     {
-        return $this->bitset & (1 << $this->ordinal) && $this->ordinal !== $this->ordinalMax;
+        return $this->ordinal !== $this->ordinalMax && $this->getBit($this->ordinal);
     }
 
     /* Countable */
@@ -198,11 +190,88 @@ public function count()
         $cnt = 0;
         $ord = 0;
         do {
-            if ($this->bitset & (1 << $ord++)) {
+            if ($this->getBit($ord++)) {
                 ++$cnt;
             }
         } while ($ord !== $this->ordinalMax);
 
         return $cnt;
     }
+
+    /**
+     * Get the binary bitset
+     * 
+     * @return string Returns the binary bitset in big-endian order
+     */
+    public function getBitset()
+    {
+        return strrev($this->bitset);
+    }
+
+    /**
+     * Set the bitset.
+     * NOTE: It resets the current position of the iterator
+     * 
+     * @param string $bitset The binary bitset in big-endian order
+     * @return void
+     * @throws InvalidArgumentException On a non string is given as Parameter
+     */
+    public function setBitset($bitset)
+    {
+        if (! is_string($bitset)) {
+            throw new InvalidArgumentException("bitset must be a string");
+        }
+        
+        $bitset = strrev($bitset);
+        $size   = ceil($this->ordinalMax / 8);
+        $sizeIn = strlen($bitset);
+        
+        if ($sizeIn < $size) {
+            // add "\0" if the given bitset is not long enough
+            $bitset .= str_repeat("\0", $size - $sizeIn);
+        } elseif ($sizeIn > $size) {
+            $bitset = substr($bitset, 0, $size);
+        }
+        
+        $this->bitset = $bitset;
+        
+        $this->rewind();
+    }
+
+    /**
+     * get a bit at the given ordinal
+     * 
+     * @param $ordinal int Number of bit to get
+     * @return boolean
+     */
+    private function getBit($ordinal)
+    {
+        return (ord($this->bitset[(int) ($ordinal / 8)]) & 1 << ($ordinal % 8)) !== 0;
+    }
+
+    /**
+     * set a bit at the given ordinal
+     * 
+     * @param $ordinal int
+     *            number of bit to manipulate
+     * @return void
+     */
+    private function setBit($ordinal)
+    {
+        $byte = (int) ($ordinal / 8);
+        $this->bitset[$byte] = $this->bitset[$byte] | chr(1 << ($ordinal % 8));
+    }
+
+    /**
+     * reset a bit at the given ordinal
+     * 
+     * @param $ordinal int
+     *            number of bit to set to false
+     * @return void
+     */
+    private function unsetBit($ordinal)
+    {
+        $byte = (int) ($ordinal / 8);
+        $this->bitset[$byte] = $this->bitset[$byte] & chr(~ (1 << ($ordinal % 8)));
+    }
 }

tests/MabeEnumTest/EnumSetTest.php

@@ -8,6 +8,7 @@
 use MabeEnumTest\TestAsset\EnumInheritance;
 use MabeEnumTest\TestAsset\Enum32;
 use MabeEnumTest\TestAsset\Enum64;
+use MabeEnumTest\TestAsset\Enum65;
 use PHPUnit_Framework_TestCase as TestCase;
 
 /**
@@ -224,10 +225,6 @@ public function test32EnumerationsSet()
 
     public function test64EnumerationsSet()
     {
-        if (PHP_INT_SIZE === 4) {
-            $this->setExpectedException('OutOfRangeException');
-        }
-
         $enumSet = new EnumSet('MabeEnumTest\TestAsset\Enum64');
         foreach (Enum64::getConstants() as $name => $value) {
             $this->assertFalse($enumSet->contains($value));
@@ -247,7 +244,45 @@ public function test64EnumerationsSet()
 
     public function test65EnumerationsSet()
     {
-        $this->setExpectedException('OutOfRangeException');
-        new EnumSet('MabeEnumTest\TestAsset\Enum65');
+        $enum = new EnumSet('MabeEnumTest\TestAsset\Enum65');
+
+        $this->assertNull($enum->attach(Enum65::getByOrdinal(64)));
+        $enum->next();
+        $this->assertTrue($enum->valid());
+    }
+
+    public function testBitset()
+    {
+        $enumSet1 = new EnumSet('MabeEnumTest\TestAsset\Enum65');
+        
+        $enum1 = Enum65::ONE;
+        $enum2 = Enum65::TWO;
+        $enum3 = Enum65::SIXTYFIVE;
+        $enum4 = Enum65::SIXTYFOUR;
+        
+        $this->assertNull($enumSet1->attach($enum1));
+        $this->assertNull($enumSet1->attach($enum2));
+        $this->assertNull($enumSet1->attach($enum3));
+        $this->assertNull($enumSet1->attach($enum4));
+        
+        $this->assertNull($enumSet1->detach($enum1));
+        $bitset = $enumSet1->getBitset();
+        $this->assertTrue(strlen($bitset) > 8);
+        $enumSet2 = new EnumSet('MabeEnumTest\TestAsset\Enum65');
+        $enumSet2->setBitset($bitset);
+        
+        $this->assertFalse($enumSet2->contains($enum1));
+        $this->assertTrue($enumSet2->contains($enum2));
+        $this->assertTrue($enumSet2->contains($enum3));
+        $this->assertTrue($enumSet2->contains($enum4));
+        $this->assertTrue($enumSet2->count() == 3);
+    }
+
+    public function testFalseBitsetArgumentExceptionIfNotString()
+    {
+        $this->setExpectedException('InvalidArgumentException');
+        
+        $enum = new EnumSet('MabeEnumTest\TestAsset\Enum65');
+        $enum->setBitset(0);
     }
 }