marc-mabe / php-enum

src/EnumMap.php

Indentation +1 added lines, -1 removed lines

@@ -43,7 +43,7 @@
         if (!\is_subclass_of($enumeration, Enum::class)) {
             throw new InvalidArgumentException(\sprintf(
                 '%s can handle subclasses of %s only',
-                 __CLASS__,
+                    __CLASS__,
                 Enum::class
             ));
         }

src/EnumSet.php

Braces +48 added lines, -16 removed lines

@@ -804,14 +804,30 @@ 
             }
 
             $ord = \ord($bitset[$bytePos]);
-            if ($ord & 0b00000001) ++$count;
-            if ($ord & 0b00000010) ++$count;
-            if ($ord & 0b00000100) ++$count;
-            if ($ord & 0b00001000) ++$count;
-            if ($ord & 0b00010000) ++$count;
-            if ($ord & 0b00100000) ++$count;
-            if ($ord & 0b01000000) ++$count;
-            if ($ord & 0b10000000) ++$count;
+            if ($ord & 0b00000001) {
+                ++$count;
+            }
+            if ($ord & 0b00000010) {
+                ++$count;
+            }
+            if ($ord & 0b00000100) {
+                ++$count;
+            }
+            if ($ord & 0b00001000) {
+                ++$count;
+            }
+            if ($ord & 0b00010000) {
+                ++$count;
+            }
+            if ($ord & 0b00100000) {
+                ++$count;
+            }
+            if ($ord & 0b01000000) {
+                ++$count;
+            }
+            if ($ord & 0b10000000) {
+                ++$count;
+            }
         }
         return $count;
     }
@@ -843,14 +859,30 @@ 
             $byte = $bitset & $bitChk;
             if ($byte) {
                 $byte = $byte >> $bitPos;
-                if ($byte & 0b00000001) ++$count;
-                if ($byte & 0b00000010) ++$count;
-                if ($byte & 0b00000100) ++$count;
-                if ($byte & 0b00001000) ++$count;
-                if ($byte & 0b00010000) ++$count;
-                if ($byte & 0b00100000) ++$count;
-                if ($byte & 0b01000000) ++$count;
-                if ($byte & 0b10000000) ++$count;
+                if ($byte & 0b00000001) {
+                    ++$count;
+                }
+                if ($byte & 0b00000010) {
+                    ++$count;
+                }
+                if ($byte & 0b00000100) {
+                    ++$count;
+                }
+                if ($byte & 0b00001000) {
+                    ++$count;
+                }
+                if ($byte & 0b00010000) {
+                    ++$count;
+                }
+                if ($byte & 0b00100000) {
+                    ++$count;
+                }
+                if ($byte & 0b01000000) {
+                    ++$count;
+                }
+                if ($byte & 0b10000000) {
+                    ++$count;
+                }
             }
 
             if ($bitset <= $bitChk) {

Spacing +4 added lines, -4 removed lines

@@ -86,7 +86,7 @@ 
         // we will switch this into a binary bitset
         if ($this->enumerationCount > \PHP_INT_SIZE * 8) {
             // init binary bitset with zeros
-            $this->bitset = $this->emptyBitset = \str_repeat("\0", (int)\ceil($this->enumerationCount / 8));
+            $this->bitset = $this->emptyBitset = \str_repeat("\0", (int) \ceil($this->enumerationCount / 8));
 
             // switch internal binary bitset functions
             $this->fnDoGetIterator       = 'doGetIteratorBin';
@@ -332,7 +332,7 @@ 
                 throw new InvalidArgumentException('out-of-range bits detected');
             }
 
-            $this->bitset = \substr($bitset, 0, -1) . $lastByteExpected;
+            $this->bitset = \substr($bitset, 0, -1).$lastByteExpected;
         }
 
         $this->bitset = $bitset;
@@ -1054,7 +1054,7 @@ 
     private function doGetBinaryBitsetLeInt()
     {
         $bin = \pack(\PHP_INT_SIZE === 8 ? 'P' : 'V', $this->bitset);
-        return \substr($bin, 0, (int)\ceil($this->enumerationCount / 8));
+        return \substr($bin, 0, (int) \ceil($this->enumerationCount / 8));
     }
 
     /**
@@ -1112,6 +1112,6 @@ 
      */
     private function doGetBitInt($ordinal)
     {
-        return (bool)($this->bitset & (1 << $ordinal));
+        return (bool) ($this->bitset & (1 << $ordinal));
     }
 }

src/EnumSerializableTrait.php

Spacing +3 added lines, -3 removed lines

@@ -53,14 +53,14 @@
         $name      = \array_search($value, $constants, true);
         if ($name === false) {
             $message = \is_scalar($value)
-                ? 'Unknown value ' . \var_export($value, true)
-                : 'Invalid value of type ' . (\is_object($value) ? \get_class($value) : \gettype($value));
+                ? 'Unknown value '.\var_export($value, true)
+                : 'Invalid value of type '.(\is_object($value) ? \get_class($value) : \gettype($value));
             throw new RuntimeException($message);
         }
 
         $class      = static::class;
         $enumerator = $this;
-        $closure    = function () use ($class, $name, $value, $enumerator) {
+        $closure    = function() use ($class, $name, $value, $enumerator) {
             if ($value !== null && $this->value !== null) {
                 throw new LogicException('Do not call this directly - please use unserialize($enum) instead');
             }

src/Enum.php

Spacing +5 added lines, -5 removed lines

@@ -198,7 +198,7 @@ 
                 'Unknown value %s for enumeration %s',
                 \is_scalar($value)
                     ? \var_export($value, true)
-                    : 'of type ' . (\is_object($value) ? \get_class($value) : \gettype($value)),
+                    : 'of type '.(\is_object($value) ? \get_class($value) : \gettype($value)),
                 static::class
             ));
         }
@@ -221,14 +221,14 @@ 
             return self::$instances[static::class][$name];
         }
 
-        $const = static::class . "::{$name}";
+        $const = static::class."::{$name}";
         if (!\defined($const)) {
             throw new InvalidArgumentException("{$const} not defined");
         }
 
         assert(
             self::noAmbiguousValues(static::getConstants()),
-            'Ambiguous enumerator values detected for ' . static::class
+            'Ambiguous enumerator values detected for '.static::class
         );
 
         return self::$instances[static::class][$name] = new static(\constant($const));
@@ -326,7 +326,7 @@ 
             // Enumerators must be defined as public class constants
             foreach ($reflection->getReflectionConstants() as $reflConstant) {
                 if ($reflConstant->isPublic()) {
-                    $scopeConstants[ $reflConstant->getName() ] = $reflConstant->getValue();
+                    $scopeConstants[$reflConstant->getName()] = $reflConstant->getValue();
                 }
             }
 
@@ -335,7 +335,7 @@ 
 
         assert(
             self::noAmbiguousValues($constants),
-            'Ambiguous enumerator values detected for ' . static::class
+            'Ambiguous enumerator values detected for '.static::class
         );
 
         self::$names[static::class] = \array_keys($constants);