MabeEnum\EnumSet

Complexity

Total Complexity

107

Size/Duplication

Total Lines	816
Duplicated Lines	0 %

Test Coverage

Coverage

95.42%

Importance

Changes

0

42 Methods

Rating	Name	Duplication	Size	Complexity
F	doCountInt()	0	34	13
A	getOrdinals()	0	3	1
A	isEqual()	0	4	2
A	symDiff()	0	12	2
A	withoutEnumerator()	0	5	1
A	isSubset()	0	4	2
A	doSetBinaryBitsetLeInt()	0	19	5
A	getIterator()	0	3	1
A	withEnumerators()	0	7	2
A	__construct()	0	34	5
A	getBit()	0	7	3
A	doUnsetBitInt()	0	3	1
A	withoutEnumerators()	0	7	2
A	doGetOrdinalsBin()	0	19	5
A	contains()	0	3	1
A	getValues()	0	8	2
A	doGetIteratorBin()	0	15	5
C	doCountBin()	0	22	11
A	doGetBitInt()	0	3	1
A	doGetBinaryBitsetLeInt()	0	4	2
A	doSetBitInt()	0	3	1
A	withBinaryBitsetBe()	0	3	1
A	doGetBinaryBitsetLeBin()	0	3	1
A	getEnumeration()	0	3	1
A	withBinaryBitsetLe()	0	5	1
A	doSetBitBin()	0	4	1
A	intersect()	0	12	2
A	getEnumerators()	0	8	2
A	getNames()	0	8	2
A	count()	0	3	1
A	withEnumerator()	0	5	1
A	getBinaryBitsetLe()	0	3	1
A	withBit()	0	13	4
A	union()	0	12	2
A	diff()	0	12	2
A	doGetBitBin()	0	3	1
A	doUnsetBitBin()	0	4	1
A	getBinaryBitsetBe()	0	3	1
A	doSetBinaryBitsetLeBin()	0	28	6
A	doGetIteratorInt()	0	7	3
A	doGetOrdinalsInt()	0	11	3
A	isSuperset()	0	4	2

<?php

declare(strict_types=1);

namespace MabeEnum;

use Countable;
use InvalidArgumentException;
use Iterator;
use IteratorAggregate;
use OutOfBoundsException;

/**
 * A set of enumerators of the given enumeration (EnumSet<T>)
 * based on an integer or binary bitset depending of given enumeration size.
 *
 * @copyright 2019 Marc Bennewitz
 * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
 * @link http://github.com/marc-mabe/php-enum for the canonical source repository
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

class EnumSet implements IteratorAggregate, Countable
{
    /**
     * The classname of the Enumeration
     * @var string
     */
    private $enumeration;

Expected 1 blank line before member var; 0 found

Private member variable "enumeration" must contain a leading underscore

    /**
     * Number of enumerators defined in the enumeration
     * @var int
     */
    private $enumerationCount;

Private member variable "enumerationCount" must contain a leading underscore

    /**
     * Integer or binary (little endian) bitset
     * @var int|string
     */
    private $bitset = 0;

Private member variable "bitset" must contain a leading underscore

    /**#@+
     * Defines private method names to be called depended of how the bitset type was set too.
     * ... Integer or binary bitset.
     * ... *Int or *Bin method
     * 
     * @var string
     */
    private $fnDoGetIterator       = 'doGetIteratorInt';

Private member variable "fnDoGetIterator" must contain a leading underscore

    private $fnDoCount             = 'doCountInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoCount" must contain a leading underscore

    private $fnDoGetOrdinals       = 'doGetOrdinalsInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoGetOrdinals" must contain a leading underscore

    private $fnDoGetBit            = 'doGetBitInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoGetBit" must contain a leading underscore

    private $fnDoSetBit            = 'doSetBitInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoSetBit" must contain a leading underscore

    private $fnDoUnsetBit          = 'doUnsetBitInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoUnsetBit" must contain a leading underscore

    private $fnDoGetBinaryBitsetLe = 'doGetBinaryBitsetLeInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoGetBinaryBitsetLe" must contain a leading underscore

    private $fnDoSetBinaryBitsetLe = 'doSetBinaryBitsetLeInt';

Expected 1 blank line before member var; 0 found

Private member variable "fnDoSetBinaryBitsetLe" must contain a leading underscore

    /**#@-*/

    /**
     * Constructor
     *
     * @param string $enumeration The classname of the enumeration

Parameter comment must end with a full stop

Expected 8 spaces after parameter type; 1 found

     * @param iterable|null $enumerators iterable list of enumerators initializing the set

Parameter comment must start with a capital letter

Parameter comment must end with a full stop

     * @throws InvalidArgumentException

Comment missing for @throws tag in function comment

     */
    public function __construct(string $enumeration, iterable $enumerators = null)

Incorrect spacing between argument "$enumerators" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$enumerators"; expected 0 but found 1

    {
        if (!\is_subclass_of($enumeration, Enum::class)) {
            throw new InvalidArgumentException(\sprintf(
                '%s can handle subclasses of %s only',
                __METHOD__,
                Enum::class
            ));
        }

        $this->enumeration      = $enumeration;
        $this->enumerationCount = \count($enumeration::getConstants());

        // By default the bitset is initialized as integer bitset
        // in case the enumeraton has more enumerators then integer bits
        // we will switch this into a binary bitset
        if ($this->enumerationCount > \PHP_INT_SIZE * 8) {
            // init binary bitset with zeros
            $this->bitset = \str_repeat("\0", (int)\ceil($this->enumerationCount / 8));

            // switch internal binary bitset functions
            $this->fnDoGetIterator       = 'doGetIteratorBin';
            $this->fnDoCount             = 'doCountBin';
            $this->fnDoGetOrdinals       = 'doGetOrdinalsBin';
            $this->fnDoGetBit            = 'doGetBitBin';
            $this->fnDoSetBit            = 'doSetBitBin';
            $this->fnDoUnsetBit          = 'doUnsetBitBin';
            $this->fnDoGetBinaryBitsetLe = 'doGetBinaryBitsetLeBin';
            $this->fnDoSetBinaryBitsetLe = 'doSetBinaryBitsetLeBin';
        }

        if ($enumerators !== null) {
            foreach ($enumerators as $enumerator) {
                $this->{$this->fnDoSetBit}($enumeration::get($enumerator)->getOrdinal());
            }
        }
    }

    /**
     * Get the classname of the enumeration
     * @return string
     */
    public function getEnumeration(): string
    {
        return $this->enumeration;
    }

    /**
     * Adds the given enumerator
     * @param Enum|null|bool|int|float|string|array $enumerator Enumerator object or value to remove

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     */
    public function withEnumerator($enumerator): self
    {
        $clone = clone $this;
        $clone->{$this->fnDoSetBit}(($this->enumeration)::get($enumerator)->getOrdinal());
        return $clone;
    }

    /**
     * Adds the given enumerators
     * @param iterable $enumerators Iterable list of enumerator objects or values to add

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     */
    public function withEnumerators(iterable $enumerators): self
    {
        $clone = clone $this;
        foreach ($enumerators as $enumerator) {
            $clone->{$this->fnDoSetBit}(($this->enumeration)::get($enumerator)->getOrdinal());
        }
        return $clone;
    }

    /**
     * Removes an enumerator
     * @param Enum|null|bool|int|float|string|array $enumerator Enumerator object or value to remove

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     */
    public function withoutEnumerator($enumerator): self
    {
        $clone = clone $this;
        $clone->{$this->fnDoUnsetBit}(($this->enumeration)::get($enumerator)->getOrdinal());
        return $clone;
    }

    /**
     * Removes enumerators
     * @param iterable $enumerators Iterable list of enumerator objects or values to remove

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     */
    public function withoutEnumerators(iterable $enumerators): self
    {
        $clone = clone $this;
        foreach ($enumerators as $enumerator) {
            $clone->{$this->fnDoUnsetBit}(($this->enumeration)::get($enumerator)->getOrdinal());
        }
        return $clone;
    }

    /**
     * Test if the given enumerator exists
     * @param Enum|null|bool|int|float|string|array $enumerator

Missing parameter comment

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function contains($enumerator): bool
    {
        return $this->{$this->fnDoGetBit}(($this->enumeration)::get($enumerator)->getOrdinal());
    }

    /* IteratorAggregate */

    /**
     * Get a new iterator
     * @return Iterator
     * @uses doGetIteratorInt()
     * @uses doGetIteratorBin()
     */
    public function getIterator(): Iterator
    {
        return $this->{$this->fnDoGetIterator}();
    }

    /**
     * Get a new Iterator.
     *
     * This is the binary bitset implementation.
     *
     * @return Iterator
     * @see getIterator()
     * @see goGetIteratorInt()
     */
    private function doGetIteratorBin()
    {
        $bitset   = $this->bitset;
        $byteLen  = \strlen($bitset);
        for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
            if ($bitset[$bytePos] === "\0") {
                // fast skip null byte
                continue;
            }

            $ord = \ord($bitset[$bytePos]);
            for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
                if ($ord & (1 << $bitPos)) {
                    $ordinal = $bytePos * 8 + $bitPos;
                    yield $ordinal => ($this->enumeration)::byOrdinal($ordinal);
                }
            }
        }
    }

    /**
     * Get a new Iterator.
     *
     * This is the integer bitset implementation.
     *
     * @return Iterator
     * @see getIterator()
     * @see doGetIteratorBin()
     */
    private function doGetIteratorInt()
    {
        $count  = $this->enumerationCount;
        $bitset = $this->bitset;
        for ($ordinal = 0; $ordinal < $count; ++$ordinal) {
            if ($bitset & (1 << $ordinal)) {
                yield $ordinal => ($this->enumeration)::byOrdinal($ordinal);
            }
        }
    }

    /* Countable */

    /**
     * Count the number of elements
     *
     * @return int

Expected "integer" but found "int" for function return type

     * @uses doCountBin()
     * @uses doCountInt()
     */
    public function count(): int
    {
        return $this->{$this->fnDoCount}();
    }

    /**
     * Count the number of elements.
     *
     * This is the binary bitset implementation.
     *
     * @return int

Expected "integer" but found "int" for function return type

     * @see count()
     * @see doCountInt()
     */
    private function doCountBin()
    {
        $count   = 0;
        $bitset  = $this->bitset;
        $byteLen = \strlen($bitset);
        for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
            if ($bitset[$bytePos] === "\0") {
                // fast skip null byte
                continue;
            }

            $ord = \ord($bitset[$bytePos]);
            if ($ord & 0b00000001) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b00000010) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b00000100) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b00001000) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b00010000) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b00100000) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b01000000) ++$count;

It is generally a best practice to always use braces with control structures.

            if ($ord & 0b10000000) ++$count;

It is generally a best practice to always use braces with control structures.

        }
        return $count;
    }

    /**
     * Count the number of elements.
     *
     * This is the integer bitset implementation.
     *
     * @return int

Expected "integer" but found "int" for function return type

     * @see count()
     * @see doCountBin()
     */
    private function doCountInt()
    {
        $count  = 0;
        $bitset = $this->bitset;

        // PHP does not support right shift unsigned
        if ($bitset < 0) {
            $count  = 1;
            $bitset = $bitset & \PHP_INT_MAX;
        }

        // iterate byte by byte and count set bits
        $phpIntBitSize = \PHP_INT_SIZE * 8;
        for ($bitPos = 0; $bitPos < $phpIntBitSize; $bitPos += 8) {
            $bitChk = 0xff << $bitPos;
            $byte = $bitset & $bitChk;
            if ($byte) {
                $byte = $byte >> $bitPos;
                if ($byte & 0b00000001) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b00000010) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b00000100) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b00001000) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b00010000) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b00100000) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b01000000) ++$count;

It is generally a best practice to always use braces with control structures.

                if ($byte & 0b10000000) ++$count;

It is generally a best practice to always use braces with control structures.

            }

            if ($bitset <= $bitChk) {
                break;
            }
        }

        return $count;
    }

    /**
     * Check if this EnumSet is the same as other
     * @param EnumSet $other

Missing parameter comment

     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function isEqual(EnumSet $other): bool
    {
        return $this->enumeration === $other->enumeration
            && $this->bitset === $other->bitset;
    }

    /**
     * Check if this EnumSet is a subset of other
     * @param EnumSet $other

Missing parameter comment

     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function isSubset(EnumSet $other): bool
    {
        return $this->enumeration === $other->enumeration
            && ($this->bitset & $other->bitset) === $this->bitset;
    }

    /**
     * Check if this EnumSet is a superset of other
     * @param EnumSet $other

Missing parameter comment

     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function isSuperset(EnumSet $other): bool
    {
        return $this->enumeration === $other->enumeration
            && ($this->bitset | $other->bitset) === $this->bitset;
    }

    /**
     * Produce a new set with enumerators from both this and other (this | other)
     *
     * @param EnumSet $other EnumSet of the same enumeration to produce the union

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException If $other doesn't match the enumeration

@throws tag comment must end with a full stop

     */
    public function union(EnumSet $other): self
    {
        if ($this->enumeration !== $other->enumeration) {
            throw new InvalidArgumentException(\sprintf(
                'Other should be of the same enumeration as this %s',
                $this->enumeration
            ));
        }

        $clone = clone $this;
        $clone->bitset = $this->bitset | $other->bitset;
        return $clone;
    }

    /**
     * Produce a new set with enumerators common to both this and other (this & other)
     *
     * @param EnumSet $other EnumSet of the same enumeration to produce the intersect

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException If $other doesn't match the enumeration

@throws tag comment must end with a full stop

     */
    public function intersect(EnumSet $other): self
    {
        if ($this->enumeration !== $other->enumeration) {
            throw new InvalidArgumentException(\sprintf(
                'Other should be of the same enumeration as this %s',
                $this->enumeration
            ));
        }

        $clone = clone $this;
        $clone->bitset = $this->bitset & $other->bitset;
        return $clone;
    }

    /**
     * Produce a new set with enumerators in this but not in other (this - other)
     *
     * @param EnumSet $other EnumSet of the same enumeration to produce the diff

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException If $other doesn't match the enumeration

@throws tag comment must end with a full stop

     */
    public function diff(EnumSet $other): self
    {
        if ($this->enumeration !== $other->enumeration) {
            throw new InvalidArgumentException(\sprintf(
                'Other should be of the same enumeration as this %s',
                $this->enumeration
            ));
        }

        $clone = clone $this;
        $clone->bitset = $this->bitset & ~$other->bitset;
        return $clone;
    }

    /**
     * Produce a new set with enumerators in either this and other but not in both (this ^ other)
     *
     * @param EnumSet $other EnumSet of the same enumeration to produce the symmetric difference

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException If $other doesn't match the enumeration

@throws tag comment must end with a full stop

     */
    public function symDiff(EnumSet $other): self
    {
        if ($this->enumeration !== $other->enumeration) {
            throw new InvalidArgumentException(\sprintf(
                'Other should be of the same enumeration as this %s',
                $this->enumeration
            ));
        }

        $clone = clone $this;
        $clone->bitset = $this->bitset ^ $other->bitset;
        return $clone;
    }

    /**
     * Get ordinal numbers of the defined enumerators as array
     * @return int[]
     * @uses  doGetOrdinalsBin()
     * @uses  doGetOrdinalsInt()
     */
    public function getOrdinals(): array
    {
        return $this->{$this->fnDoGetOrdinals}();
    }

    /**
     * Get ordinal numbers of the defined enumerators as array.
     *
     * This is the binary bitset implementation.
     *
     * @return int[]
     * @see getOrdinals()
     * @see goGetOrdinalsInt()
     */
    private function doGetOrdinalsBin()
    {
        $ordinals = [];
        $bitset   = $this->bitset;
        $byteLen  = \strlen($bitset);
        for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
            if ($bitset[$bytePos] === "\0") {
                // fast skip null byte
                continue;
            }

            $ord = \ord($bitset[$bytePos]);
            for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
                if ($ord & (1 << $bitPos)) {
                    $ordinals[] = $bytePos * 8 + $bitPos;
                }
            }
        }
        return $ordinals;
    }

    /**
     * Get ordinal numbers of the defined enumerators as array.
     *
     * This is the integer bitset implementation.
     *
     * @return int[]
     * @see getOrdinals()
     * @see doGetOrdinalsBin()
     */
    private function doGetOrdinalsInt()
    {
        $ordinals = [];
        $count    = $this->enumerationCount;
        $bitset   = $this->bitset;
        for ($ordinal = 0; $ordinal < $count; ++$ordinal) {
            if ($bitset & (1 << $ordinal)) {
                $ordinals[] = $ordinal;
            }
        }
        return $ordinals;
    }

    /**
     * Get values of the defined enumerators as array
     * @return mixed[]
     */
    public function getValues(): array
    {
        $enumeration = $this->enumeration;
        $values      = [];
        foreach ($this->getOrdinals() as $ord) {
            $values[] = $enumeration::byOrdinal($ord)->getValue();
        }
        return $values;
    }

    /**
     * Get names of the defined enumerators as array
     * @return string[]
     */
    public function getNames(): array
    {
        $enumeration = $this->enumeration;
        $names       = [];
        foreach ($this->getOrdinals() as $ord) {
            $names[] = $enumeration::byOrdinal($ord)->getName();
        }
        return $names;
    }

    /**
     * Get the defined enumerators as array
     * @return Enum[]
     */
    public function getEnumerators(): array
    {
        $enumeration = $this->enumeration;
        $enumerators = [];
        foreach ($this->getOrdinals() as $ord) {
            $enumerators[] = $enumeration::byOrdinal($ord);
        }
        return $enumerators;
    }

    /**
     * Get binary bitset in little-endian order
     * 
     * @return string
     * @uses doGetBinaryBitsetLeBin()
     * @uses doGetBinaryBitsetLeInt()
     */
    public function getBinaryBitsetLe(): string
    {
        return $this->{$this->fnDoGetBinaryBitsetLe}();
    }

    /**
     * Get binary bitset in little-endian order.
     *
     * This is the binary bitset implementation.
     *
     * @return string
     * @see getBinaryBitsetLe()
     * @see doGetBinaryBitsetLeInt()
     */
    private function doGetBinaryBitsetLeBin()
    {
        return $this->bitset;
    }

    /**
     * Get binary bitset in little-endian order.
     *
     * This is the integer bitset implementation.
     *
     * @return string
     * @see getBinaryBitsetLe()
     * @see doGetBinaryBitsetLeBin()
     */
    private function doGetBinaryBitsetLeInt()
    {
        $bin = \pack(\PHP_INT_SIZE === 8 ? 'P' : 'V', $this->bitset);
        return \substr($bin, 0, (int)\ceil($this->enumerationCount / 8));
    }

    /**
     * Set binary bitset in little-endian order
     *
     * @param string $bitset

Missing parameter comment

     * @return static
     * @throws InvalidArgumentException On out-of-range bits given as input bitset

@throws tag comment must end with a full stop

     * @uses doSetBinaryBitsetLeBin()
     * @uses doSetBinaryBitsetLeInt()
     */
    public function withBinaryBitsetLe(string $bitset): self
    {
        $clone = clone $this;
        $clone->{$this->fnDoSetBinaryBitsetLe}($bitset);
        return $clone;
    }

    /**
     * Set binary bitset in little-endian order
     *
     * @param string $bitset

Missing parameter comment

     * @return void
     * @throws InvalidArgumentException On out-of-range bits given as input bitset

@throws tag comment must end with a full stop

     * @see setBinaryBitsetLeBin()
     * @see doSetBinaryBitsetLeInt()
     */
    private function doSetBinaryBitsetLeBin($bitset): void

Type hint "string" missing for $bitset

    {
        $size   = \strlen($this->bitset);
        $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) {
            if (\ltrim(\substr($bitset, $size), "\0") !== '') {
                throw new InvalidArgumentException('out-of-range bits detected');
            }
            $bitset = \substr($bitset, 0, $size);
        }

        // truncate out-of-range bits of last byte
        $lastByteMaxOrd = $this->enumerationCount % 8;
        if ($lastByteMaxOrd !== 0) {
            $lastByte         = $bitset[-1];
            $lastByteExpected = \chr((1 << $lastByteMaxOrd) - 1) & $lastByte;
            if ($lastByte !== $lastByteExpected) {
                throw new InvalidArgumentException('out-of-range bits detected');
            }

            $this->bitset = \substr($bitset, 0, -1) . $lastByteExpected;
        }

        $this->bitset = $bitset;
    }

    /**
     * Set binary bitset in little-endian order
     *
     * @param string $bitset

Missing parameter comment

     * @return void
     * @throws InvalidArgumentException On out-of-range bits given as input bitset

@throws tag comment must end with a full stop

     * @see setBinaryBitsetLeBin()
     * @see doSetBinaryBitsetLeBin()
     */
    private function doSetBinaryBitsetLeInt($bitset): void

Type hint "string" missing for $bitset

    {
        $len = \strlen($bitset);
        $int = 0;
        for ($i = 0; $i < $len; ++$i) {
            $ord = \ord($bitset[$i]);

            if ($ord && $i > \PHP_INT_SIZE - 1) {
                throw new InvalidArgumentException('out-of-range bits detected');
            }

            $int |= $ord << (8 * $i);
        }

        if ($int & (~0 << $this->enumerationCount)) {
            throw new InvalidArgumentException('out-of-range bits detected');
        }

        $this->bitset = $int;
    }

    /**
     * Get binary bitset in big-endian order
     * 
     * @return string
     */
    public function getBinaryBitsetBe(): string
    {
        return \strrev($this->bitset);
    }

    /**
     * Set binary bitset in big-endian order
     *
     * @param string $bitset

Missing parameter comment

     * @return static
     * @throws InvalidArgumentException On out-of-range bits given as input bitset

@throws tag comment must end with a full stop

     */
    public function withBinaryBitsetBe(string $bitset): self
    {
        return $this->withBinaryBitsetLe(\strrev($bitset));
    }

    /**
     * Get a bit at the given ordinal number
     *
     * @param int $ordinal Ordinal number of bit to get

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return bool

Expected "boolean" but found "bool" for function return type

     * @throws InvalidArgumentException If the given ordinal number is out-of-range

@throws tag comment must end with a full stop

     * @uses doGetBitBin()
     * @uses doGetBitInt()
     */
    public function getBit(int $ordinal): bool
    {
        if ($ordinal < 0 || $ordinal > $this->enumerationCount) {
            throw new InvalidArgumentException("Ordinal number must be between 0 and {$this->enumerationCount}");

As per coding-style, please use concatenation or sprintf for the variable $this instead of interpolation.

This line exceeds maximum limit of 100 characters; contains 113 characters

        }

        return $this->{$this->fnDoGetBit}($ordinal);
    }

    /**
     * Get a bit at the given ordinal number.
     *
     * This is the binary bitset implementation.
     *
     * @param int $ordinal Ordinal number of bit to get

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return bool

Expected "boolean" but found "bool" for function return type

     * @see getBit()
     * @see doGetBitInt()
     */
    private function doGetBitBin($ordinal)

Type hint "int" missing for $ordinal

    {
        return (\ord($this->bitset[(int) ($ordinal / 8)]) & 1 << ($ordinal % 8)) !== 0;
    }

    /**
     * Get a bit at the given ordinal number.
     *
     * This is the integer bitset implementation.
     * 
     * @param int $ordinal Ordinal number of bit to get

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return bool

Expected "boolean" but found "bool" for function return type

     * @see getBit()
     * @see doGetBitBin()
     */
    private function doGetBitInt($ordinal)

Type hint "int" missing for $ordinal

    {
        return (bool)($this->bitset & (1 << $ordinal));
    }

    /**
     * Set a bit at the given ordinal number
     *
     * @param int $ordinal Ordinal number of bit to set

Expected "integer" but found "int" for parameter type

Expected 2 spaces after parameter type; 1 found

Parameter comment must end with a full stop

     * @param bool $bit    The bit to set

Expected "boolean" but found "bool" for parameter type

Expected 5 spaces after parameter name; 4 found

Parameter comment must end with a full stop

     * @return static
     * @throws InvalidArgumentException If the given ordinal number is out-of-range

@throws tag comment must end with a full stop

     * @uses doSetBitBin()
     * @uses doSetBitInt()
     * @uses doUnsetBitBin()
     * @uses doUnsetBitInt()
     */
    public function withBit(int $ordinal, bool $bit): self
    {
        if ($ordinal < 0 || $ordinal > $this->enumerationCount) {
            throw new InvalidArgumentException("Ordinal number must be between 0 and {$this->enumerationCount}");

As per coding-style, please use concatenation or sprintf for the variable $this instead of interpolation.

This line exceeds maximum limit of 100 characters; contains 113 characters

        }

        $clone = clone $this;
        if ($bit) {
            $clone->{$this->fnDoSetBit}($ordinal);
        } else {
            $clone->{$this->fnDoUnsetBit}($ordinal);
        }
        return $clone;
    }

    /**
     * Set a bit at the given ordinal number.
     *
     * This is the binary bitset implementation.
     * 
     * @param int $ordinal Ordinal number of bit to set

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return void
     * @see setBit()
     * @see doSetBitInt()
     */
    private function doSetBitBin($ordinal): void

Type hint "int" missing for $ordinal

    {
        $byte = (int) ($ordinal / 8);
        $this->bitset[$byte] = $this->bitset[$byte] | \chr(1 << ($ordinal % 8));
    }

    /**
     * Set a bit at the given ordinal number.
     *
     * This is the binary bitset implementation.
     *
     * @param int $ordinal Ordinal number of bit to set

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return void
     * @see setBit()
     * @see doSetBitBin()
     */
    private function doSetBitInt($ordinal): void

Type hint "int" missing for $ordinal

    {
        $this->bitset = $this->bitset | (1 << $ordinal);
    }

    /**
     * Unset a bit at the given ordinal number.
     *
     * This is the binary bitset implementation.
     *
     * @param int $ordinal Ordinal number of bit to unset

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return void
     * @see setBit()
     * @see doUnsetBitInt()
     */
    private function doUnsetBitBin($ordinal): void

Type hint "int" missing for $ordinal

    {
        $byte = (int) ($ordinal / 8);
        $this->bitset[$byte] = $this->bitset[$byte] & \chr(~(1 << ($ordinal % 8)));
    }

    /**
     * Unset a bit at the given ordinal number.
     *
     * This is the integer bitset implementation.
     *
     * @param int $ordinal Ordinal number of bit to unset

Expected "integer" but found "int" for parameter type

Parameter comment must end with a full stop

     * @return void
     * @see setBit()
     * @see doUnsetBitBin()
     */
    private function doUnsetBitInt($ordinal): void

Type hint "int" missing for $ordinal

    {
        $this->bitset = $this->bitset & ~(1 << $ordinal);
    }
}