MabeEnum\AbstractEnumSet

Complexity

Total Complexity

68

Size/Duplication

Total Lines	496
Duplicated Lines	43.75 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	7	13	2
A	getEnumeration()	0	4	1
A	attach()	0	5	1
A	detach()	0	5	1
A	contains()	0	5	1
A	current()	0	9	2
A	key()	0	4	1
A	next()	9	9	3
A	rewind()	9	9	2
A	valid()	0	4	2
B	count()	18	18	5
A	isEqual()	0	5	2
A	isSubset()	8	8	2
A	isSuperset()	8	8	2
A	union()	19	19	4
A	intersect()	19	19	4
A	diff()	19	19	4
A	symDiff()	19	19	4
B	getOrdinals()	19	19	5
A	getValues()	9	9	2
A	getNames()	9	9	2
A	getEnumerators()	9	9	2
A	getBinaryBitsetLe()	0	4	1
C	setBinaryBitsetLe()	36	36	7
A	getBinaryBitsetBe()	0	4	1
A	setBinaryBitsetBe()	0	7	2
A	getBit()	0	4	1
A	setBit()	0	5	1
A	unsetBit()	0	5	1

<?php

namespace MabeEnum;

use Iterator;
use Countable;
use InvalidArgumentException;

/**
 * This EnumSet is based on a bitset of a binary string.
 *
 * @link http://github.com/marc-mabe/php-enum for the canonical source repository
 * @copyright Copyright (c) 2015 Marc Bennewitz
 * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
 */
abstract class AbstractEnumSet implements Iterator, Countable
{
    /**
     * The classname of the Enumeration
     * @var string
     */
    protected $enumeration;

    /**
     * Ordinal number of current iterator position
     * @var int
     */
    protected $ordinal = 0;

    /**
     * Highest possible ordinal number
     * @var int
     */
    protected $ordinalMax;

    /**
     * Constructor
     *
     * @param string $enumeration The classname of the enumeration
     * @throws InvalidArgumentException
     */
    public function __construct($enumeration)
    {
        if (!is_subclass_of($enumeration, Enum::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \MabeEnum\Enum::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

This code seems to be duplicated across your project.

            throw new InvalidArgumentException(sprintf(
                "%s can handle subclasses of '%s' only",
                static::class,
                Enum::class
            ));
        }
        
        $this->enumeration = $enumeration;
        $this->ordinalMax  = count($enumeration::getConstants());
    }

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

    /**
     * Attach a new enumerator or overwrite an existing one
     * @param Enum|null|boolean|int|float|string $enumerator
     * @return void
     * @throws InvalidArgumentException On an invalid given enumerator
     */
    public function attach($enumerator)
    {
        $enumeration = $this->enumeration;
        $this->setBit($enumeration::get($enumerator)->getOrdinal());
    }

    /**
     * Detach the given enumerator
     * @param Enum|null|boolean|int|float|string $enumerator
     * @return void
     * @throws InvalidArgumentException On an invalid given enumerator
     */
    public function detach($enumerator)
    {
        $enumeration = $this->enumeration;
        $this->unsetBit($enumeration::get($enumerator)->getOrdinal());
    }

    /**
     * Test if the given enumerator was attached
     * @param Enum|null|boolean|int|float|string $enumerator
     * @return boolean
     */
    public function contains($enumerator)
    {
        $enumeration = $this->enumeration;
        return $this->getBit($enumeration::get($enumerator)->getOrdinal());
    }

    /* Iterator */

    /**
     * Get the current enumerator
     * @return Enum|null Returns the current enumerator or NULL on an invalid iterator position
     */
    public function current()
    {
        if ($this->valid()) {
            $enumeration = $this->enumeration;
            return $enumeration::byOrdinal($this->ordinal);
        }

        return null;
    }

    /**
     * Get the ordinal number of the current iterator position
     * @return int
     */
    public function key()
    {
        return $this->ordinal;
    }

    /**
     * Go to the next valid iterator position.
     * If no valid iterator position is found the iterator position will be the last possible + 1.
     * @return void
     */
    public function next()

This method seems to be duplicated in your project.

    {
        do {
            if (++$this->ordinal >= $this->ordinalMax) {
                $this->ordinal = $this->ordinalMax;
                return;
            }
        } while (!$this->getBit($this->ordinal));
    }

    /**
     * Go to the first valid iterator position.
     * If no valid iterator position in found the iterator position will be 0.
     * @return void
     */
    public function rewind()

This method seems to be duplicated in your project.

    {
        if (trim($this->bitset, "\0") !== '') {

The property bitset does not exist. Did you maybe forget to declare it?

            $this->ordinal = -1;
            $this->next();
        } else {
            $this->ordinal = 0;
        }
    }

    /**
     * Test if the iterator in a valid state
     * @return boolean
     */
    public function valid()
    {
        return $this->ordinal !== $this->ordinalMax && $this->getBit($this->ordinal);
    }

    /* Countable */

    /**
     * Count the number of elements
     * @return int
     */
    public function count()

This method seems to be duplicated in your project.

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

            for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
                if ((ord($this->bitset[$bytePos]) & (1 << $bitPos)) !== 0) {
                    ++$count;
                }
            }
        }

        return $count;
    }

    /**
     * Check if this EnumSet is the same as other
     * @param EnumSet $other
     * @return bool
     */
    public function isEqual(EnumSet $other)
    {
        return $this->enumeration === $other->enumeration

The property enumeration cannot be accessed from this context as it is declared protected in class MabeEnum\EnumSet.

            && $this->bitset === $other->bitset;

The property bitset cannot be accessed from this context as it is declared private in class MabeEnum\EnumSet.

    }

    /**
     * Check if this EnumSet is a subset of other
     * @param EnumSet $other
     * @return bool
     */
    public function isSubset(EnumSet $other)

This method seems to be duplicated in your project.

    {
        if ($this->enumeration !== $other->enumeration) {

The property enumeration cannot be accessed from this context as it is declared protected in class MabeEnum\EnumSet.

            return false;
        }

        return ($this->bitset & $other->bitset) === $this->bitset;

The property bitset cannot be accessed from this context as it is declared private in class MabeEnum\EnumSet.

    }

    /**
     * Check if this EnumSet is a superset of other
     * @param EnumSet $other
     * @return bool
     */
    public function isSuperset(EnumSet $other)

This method seems to be duplicated in your project.

    {
        if ($this->enumeration !== $other->enumeration) {

The property enumeration cannot be accessed from this context as it is declared protected in class MabeEnum\EnumSet.

            return false;
        }

        return ($this->bitset | $other->bitset) === $this->bitset;

The property bitset cannot be accessed from this context as it is declared private in class MabeEnum\EnumSet.

    }

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

The parameter $other is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $bitset = $this->bitset;
        foreach (func_get_args() as $other) {
            if (!$other instanceof self || $this->enumeration !== $other->enumeration) {
                throw new InvalidArgumentException(sprintf(
                    "Others should be an instance of %s of the same enumeration as this %s",
                    __CLASS__,
                    $this->enumeration
                ));
            }

            $bitset |= $other->bitset;
        }

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

    /**
     * Produce a new set with enumerators common to both this and other (this & other)
     * @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
     * @return EnumSet
     */
    public function intersect(EnumSet $other)

The parameter $other is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $bitset = $this->bitset;
        foreach (func_get_args() as $other) {
            if (!$other instanceof self || $this->enumeration !== $other->enumeration) {
                throw new InvalidArgumentException(sprintf(
                    "Others should be an instance of %s of the same enumeration as this %s",
                    __CLASS__,
                    $this->enumeration
                ));
            }

            $bitset &= $other->bitset;
        }

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

    /**
     * Produce a new set with enumerators in this but not in other (this - other)
     * @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
     * @return EnumSet
     */
    public function diff(EnumSet $other)

The parameter $other is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $bitset = '';
        foreach (func_get_args() as $other) {
            if (!$other instanceof self || $this->enumeration !== $other->enumeration) {
                throw new InvalidArgumentException(sprintf(
                    "Others should be an instance of %s of the same enumeration as this %s",
                    __CLASS__,
                    $this->enumeration
                ));
            }

            $bitset |= $other->bitset;
        }

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

    /**
     * Produce a new set with enumerators in either this and other but not in both (this ^ (other | other))
     * @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
     * @return EnumSet
     */
    public function symDiff(EnumSet $other)

The parameter $other is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $bitset = '';
        foreach (func_get_args() as $other) {
            if (!$other instanceof self || $this->enumeration !== $other->enumeration) {
                throw new InvalidArgumentException(sprintf(
                    "Others should be an instance of %s of the same enumeration as this %s",
                    __CLASS__,
                    $this->enumeration
                ));
            }

            $bitset |= $other->bitset;
        }

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

    /**
     * Get ordinal numbers of the defined enumerators as array
     * @return int[]
     */
    public function getOrdinals()

This method seems to be duplicated in your project.

    {
        $ordinals = array();
        $byteLen  = strlen($this->bitset);

        for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
            if ($this->bitset[$bytePos] === "\0") {
                continue; // fast skip null byte
            }

            for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
                if ((ord($this->bitset[$bytePos]) & (1 << $bitPos)) !== 0) {
                    $ordinals[] = $bytePos * 8 + $bitPos;
                }
            }
        }

        return $ordinals;
    }

    /**
     * Get values of the defined enumerators as array
     * @return null[]|bool[]|int[]|float[]|string[]
     */
    public function getValues()

This method seems to be duplicated in your project.

    {
        $enumeration = $this->enumeration;
        $values      = array();
        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()

This method seems to be duplicated in your project.

    {
        $enumeration = $this->enumeration;
        $names       = array();
        foreach ($this->getOrdinals() as $ord) {
            $names[] = $enumeration::byOrdinal($ord)->getName();
        }
        return $names;
    }

    /**
     * Get the defined enumerators as array
     * @return Enum[]
     */
    public function getEnumerators()

This method seems to be duplicated in your project.

    {
        $enumeration = $this->enumeration;
        $enumerators = array();
        foreach ($this->getOrdinals() as $ord) {
            $enumerators[] = $enumeration::byOrdinal($ord);
        }
        return $enumerators;
    }

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

    /**
     * Set binary bitset in little-endian order
     *
     * NOTE: It resets the current position of the iterator
     * 
     * @param string $bitset
     * @return void
     * @throws InvalidArgumentException On a non string is given as Parameter
     */
    public function setBinaryBitsetLe($bitset)

This method seems to be duplicated in your project.

    {
        if (!is_string($bitset)) {
            throw new InvalidArgumentException('Bitset must be a string');
        }

        $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 (trim(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->ordinalMax % 8;
        if ($lastByteMaxOrd !== 0) {
            $lastByte         = $bitset[$size - 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;

        // reset the iterator position
        $this->rewind();
    }

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

    /**
     * Set binary bitset in big-endian order
     *
     * NOTE: It resets the current position of the iterator
     * 
     * @param string $bitset
     * @return void
     * @throws InvalidArgumentException On a non string is given as Parameter
     */
    public function setBinaryBitsetBe($bitset)
    {
        if (!is_string($bitset)) {
            throw new InvalidArgumentException('Bitset must be a string');
        }
        $this->setBinaryBitsetLe(strrev($bitset));
    }

    /**
     * Get a bit at the given ordinal number
     * 
     * @param $ordinal int Ordinal 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 number
     * 
     * @param $ordinal int Ordnal number of bit to set
     * @return void
     */
    private function setBit($ordinal)
    {
        $byte = (int) ($ordinal / 8);
        $this->bitset[$byte] = $this->bitset[$byte] | chr(1 << ($ordinal % 8));
    }

    /**
     * Unset a bit at the given ordinal number
     * 
     * @param $ordinal int Ordinal number of bit to unset
     * @return void
     */
    private function unsetBit($ordinal)
    {
        $byte = (int) ($ordinal / 8);
        $this->bitset[$byte] = $this->bitset[$byte] & chr(~(1 << ($ordinal % 8)));
    }
}