EnumSet::count() - Code Metrics - Inspection of "EnumSet: added methods union(), intersect(), diff(..." - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — enumset_produce ( 3d5c3d...ac9aa5 )

by Marc

created 2016-10-03 18:48 UTC

EnumSet::count() B

↳ Parent: EnumSet

Complexity

Conditions	5
Paths	3

Size

Total Lines	18
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	5

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	18
ccs	9
cts	9
cp	1
rs	8.8571
cc	5
eloc	10
nc	3
nop	0
crap	5

<?php

namespace MabeEnum;

use Iterator;
use Countable;
use InvalidArgumentException;

/**
 * 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
 * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
 */
class EnumSet implements Iterator, Countable
{
    /**
     * The classname of the Enumeration
     * @var string
     */
    private $enumeration;

    /**
     * BitSet of all attached enumerations in little endian
     * @var string
     */
    private $bitset;

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

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

    /**
     * Constructor
     *
     * @param string $enumeration The classname of the enumeration
     * @throws InvalidArgumentException
     */
    public function __construct($enumeration)
    {
        if (!is_subclass_of($enumeration, __NAMESPACE__ . '\Enum')) {
            throw new InvalidArgumentException(sprintf(
                "This EnumSet can handle subclasses of '%s' only",
                __NAMESPACE__ . '\Enum'
            ));
        }
        
        $this->enumeration = $enumeration;
        $this->ordinalMax  = count($enumeration::getConstants());
        
        // init the bitset with zeros
        $this->bitset = str_repeat("\0", ceil($this->ordinalMax / 8));
    }

    /**
     * Get the classname of enumeration this set is for
     * @return string
     * @deprecated Please use getEnumeration() instead
     */
    public function getEnumClass()
    {
        return $this->getEnumeration();
    }

    /**
     * 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::getByOrdinal($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()
    {
        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()
    {
        if (trim($this->bitset, "\0") !== '') {
            $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()
    {
        $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->getEnumeration() === $other->getEnumeration()
            && $this->getBinaryBitsetLe() === $other->getBinaryBitsetLe();
    }

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

    {
        if ($this->getEnumeration() !== $other->getEnumeration()) {
            return false;
        }

        $thisBitset = $this->getBinaryBitsetLe();
        return ($thisBitset & $other->getBinaryBitsetLe()) === $thisBitset;
    }

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

    {
        if ($this->getEnumeration() !== $other->getEnumeration()) {
            return false;
        }

        $thisBitset = $this->getBinaryBitsetLe();
        return ($thisBitset | $other->getBinaryBitsetLe()) === $thisBitset;
    }

    /**
     * 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)

    {
        $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)

    {
        $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)

    {
        $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)

    {
        $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()
    {
        $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()
    {
        $values = array();
        foreach ($this->getEnumerators() as $enumerator) {
            $values[] = $enumerator->getValue();
        }
        return $values;
    }

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

    /**
     * Get the defined enumerators as array
     * @return Enum[]
     */
    public function getEnumerators()
    {
        $enumeration = $this->enumeration;
        $enumerators = array();
        foreach ($this->getOrdinals() as $ord) {
            $enumerators[] = $enumeration::getByOrdinal($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)
    {
        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) {
            $bitset = substr($bitset, 0, $size);
        }

        // truncate out-of-range bits of last byte
        $lastByteMaxOrd = $this->ordinalMax % 8;
        if ($lastByteMaxOrd === 0) {
            $this->bitset = $bitset;
        } else {
            $lastByte     = chr($lastByteMaxOrd) & $bitset[$size - 1];
            $this->bitset = substr($bitset, 0, -1) . $lastByte;
        }

        // 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 the binary bitset
     * 
     * @return string Returns the binary bitset in big-endian order
     * @deprecated Please use getBinaryBitsetBe() instead
     */
    public function getBitset()
    {
        return $this->getBinaryBitsetBe();
    }

    /**
     * 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
     * @deprecated Please use setBinaryBitsetBe() instead
     */
    public function setBitset($bitset)
    {
        $this->setBinaryBitsetBE($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)));
    }
}


1			<?php
2
3			namespace MabeEnum;
4
5			use Iterator;
6			use Countable;
7			use InvalidArgumentException;
8
9			/**
10			* EnumSet implementation in base of an integer bit set
11			*
12			* @link http://github.com/marc-mabe/php-enum for the canonical source repository
13			* @copyright Copyright (c) 2015 Marc Bennewitz
14			* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
15			*/
16			class EnumSet implements Iterator, Countable
17			{
18			/**
19			* The classname of the Enumeration
20			* @var string
21			*/
22			private $enumeration;
23
24			/**
25			* BitSet of all attached enumerations in little endian
26			* @var string
27			*/
28			private $bitset;
29
30			/**
31			* Ordinal number of current iterator position
32			* @var int
33			*/
34			private $ordinal = 0;
35
36			/**
37			* Highest possible ordinal number
38			* @var int
39			*/
40			private $ordinalMax;
41
42			/**
43			* Constructor
44			*
45			* @param string $enumeration The classname of the enumeration
46			* @throws InvalidArgumentException
47			*/
48	46		public function __construct($enumeration)
49			{
50	46		if (!is_subclass_of($enumeration, __NAMESPACE__ . '\Enum')) {
51	1		throw new InvalidArgumentException(sprintf(
52	1		"This EnumSet can handle subclasses of '%s' only",
53			__NAMESPACE__ . '\Enum'
54	1		));
55			}
56
57	45		$this->enumeration = $enumeration;
58	45		$this->ordinalMax = count($enumeration::getConstants());
59
60			// init the bitset with zeros
61	45		$this->bitset = str_repeat("\0", ceil($this->ordinalMax / 8));
62	45		}
63
64			/**
65			* Get the classname of enumeration this set is for
66			* @return string
67			* @deprecated Please use getEnumeration() instead
68			*/
69			public function getEnumClass()
70			{
71			return $this->getEnumeration();
72			}
73
74			/**
75			* Get the classname of the enumeration
76			* @return string
77			*/
78	12		public function getEnumeration()
79			{
80	12		return $this->enumeration;
81			}
82
83			/**
84			* Attach a new enumerator or overwrite an existing one
85			* @param Enum\|null\|boolean\|int\|float\|string $enumerator
86			* @return void
87			* @throws InvalidArgumentException On an invalid given enumerator
88			*/
89	35		public function attach($enumerator)
90			{
91	35		$enumeration = $this->enumeration;
92	35		$this->setBit($enumeration::get($enumerator)->getOrdinal());
93	35		}
94
95			/**
96			* Detach the given enumerator
97			* @param Enum\|null\|boolean\|int\|float\|string $enumerator
98			* @return void
99			* @throws InvalidArgumentException On an invalid given enumerator
100			*/
101	7		public function detach($enumerator)
102			{
103	7		$enumeration = $this->enumeration;
104	7		$this->unsetBit($enumeration::get($enumerator)->getOrdinal());
105	7		}
106
107			/**
108			* Test if the given enumerator was attached
109			* @param Enum\|null\|boolean\|int\|float\|string $enumerator
110			* @return boolean
111			*/
112	11		public function contains($enumerator)
113			{
114	11		$enumeration = $this->enumeration;
115	11		return $this->getBit($enumeration::get($enumerator)->getOrdinal());
116			}
117
118			/* Iterator */
119
120			/**
121			* Get the current enumerator
122			* @return Enum\|null Returns the current enumerator or NULL on an invalid iterator position
123			*/
124	9		public function current()
125			{
126	9		if ($this->valid()) {
127	9		$enumeration = $this->enumeration;
128	9		return $enumeration::getByOrdinal($this->ordinal);
129			}
130
131	2		return null;
132			}
133
134			/**
135			* Get the ordinal number of the current iterator position
136			* @return int
137			*/
138	6		public function key()
139			{
140	6		return $this->ordinal;
141			}
142
143			/**
144			* Go to the next valid iterator position.
145			* If no valid iterator position is found the iterator position will be the last possible + 1.
146			* @return void
147			*/
148	16		public function next()
149			{
150			do {
151	16		if (++$this->ordinal >= $this->ordinalMax) {
152	4		$this->ordinal = $this->ordinalMax;
153	4		return;
154			}
155	16		} while (!$this->getBit($this->ordinal));
156	16		}
157
158			/**
159			* Go to the first valid iterator position.
160			* If no valid iterator position in found the iterator position will be 0.
161			* @return void
162			*/
163	10		public function rewind()
164			{
165	10		if (trim($this->bitset, "\0") !== '') {
166	10		$this->ordinal = -1;
167	10		$this->next();
168	10		} else {
169	1		$this->ordinal = 0;
170			}
171	10		}
172
173			/**
174			* Test if the iterator in a valid state
175			* @return boolean
176			*/
177	10		public function valid()
178			{
179	10		return $this->ordinal !== $this->ordinalMax && $this->getBit($this->ordinal);
180			}
181
182			/* Countable */
183
184			/**
185			* Count the number of elements
186			* @return int
187			*/
188	11		public function count()
189			{
190	11		$count = 0;
191	11		$byteLen = strlen($this->bitset);
192			for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
193	11		if ($this->bitset[$bytePos] === "\0") {
194	10		continue; // fast skip null byte
195	10		}
196	10
197	10		for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
198			if ((ord($this->bitset[$bytePos]) & (1 << $bitPos)) !== 0) {
199	11		++$count;
200			}
201			}
202			}
203
204			return $count;
205			}
206
207	2		/**
208			* Check if this EnumSet is the same as other
209	2		* @param EnumSet $other
210	2		* @return bool
211			*/
212			public function isEqual(EnumSet $other)
213			{
214			return $this->getEnumeration() === $other->getEnumeration()
215			&& $this->getBinaryBitsetLe() === $other->getBinaryBitsetLe();
216			}
217
218	4		/**
219			* Check if this EnumSet is a subset of other
220	4		* @param EnumSet $other
221	1		* @return bool
222			*/
223		View Code Duplication	public function isSubset(EnumSet $other)
			0 ignored issues – show Duplication introduced 2016-09-19 21:15 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
224	3		{
225	3		if ($this->getEnumeration() !== $other->getEnumeration()) {
226			return false;
227			}
228
229			$thisBitset = $this->getBinaryBitsetLe();
230			return ($thisBitset & $other->getBinaryBitsetLe()) === $thisBitset;
231			}
232
233	4		/**
234			* Check if this EnumSet is a superset of other
235	4		* @param EnumSet $other
236	1		* @return bool
237			*/
238		View Code Duplication	public function isSuperset(EnumSet $other)
			0 ignored issues – show Duplication introduced 2016-09-19 21:15 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
239	3		{
240	3		if ($this->getEnumeration() !== $other->getEnumeration()) {
241			return false;
242			}
243
244			$thisBitset = $this->getBinaryBitsetLe();
245			return ($thisBitset \| $other->getBinaryBitsetLe()) === $thisBitset;
246			}
247
248	1		/**
249			* Produce a new set with enumerators from both this and other (this \| other)
250	1		* @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
251	1		* @return EnumSet
252	1		*/
253		View Code Duplication	public function union(EnumSet $other)
			0 ignored issues – show Unused Code introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report The parameter `$other` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
254			{
255			$bitset = $this->bitset;
256			foreach (func_get_args() as $other) {
257			if (!$other instanceof self \|\| $this->enumeration !== $other->enumeration) {
258			throw new InvalidArgumentException(sprintf(
259			"Others should be an instance of %s of the same enumeration as this %s",
260	1		__CLASS__,
261	1		$this->enumeration
262			));
263	1		}
264	1
265	1		$bitset \|= $other->bitset;
266			}
267
268			$clone = clone $this;
269			$clone->bitset = $bitset;
270			return $clone;
271			}
272
273	1		/**
274			* Produce a new set with enumerators common to both this and other (this & other)
275	1		* @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
276	1		* @return EnumSet
277	1		*/
278		View Code Duplication	public function intersect(EnumSet $other)
			0 ignored issues – show Unused Code introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report The parameter `$other` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
279			{
280			$bitset = $this->bitset;
281			foreach (func_get_args() as $other) {
282			if (!$other instanceof self \|\| $this->enumeration !== $other->enumeration) {
283			throw new InvalidArgumentException(sprintf(
284			"Others should be an instance of %s of the same enumeration as this %s",
285	1		__CLASS__,
286	1		$this->enumeration
287			));
288	1		}
289	1
290	1		$bitset &= $other->bitset;
291			}
292
293			$clone = clone $this;
294			$clone->bitset = $bitset;
295			return $clone;
296			}
297
298	1		/**
299			* Produce a new set with enumerators in this but not in other (this - other)
300	1		* @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
301	1		* @return EnumSet
302	1		*/
303		View Code Duplication	public function diff(EnumSet $other)
			0 ignored issues – show Unused Code introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report The parameter `$other` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
304			{
305			$bitset = '';
306			foreach (func_get_args() as $other) {
307			if (!$other instanceof self \|\| $this->enumeration !== $other->enumeration) {
308			throw new InvalidArgumentException(sprintf(
309			"Others should be an instance of %s of the same enumeration as this %s",
310	1		__CLASS__,
311	1		$this->enumeration
312			));
313	1		}
314	1
315	1		$bitset \|= $other->bitset;
316			}
317
318			$clone = clone $this;
319			$clone->bitset = $this->bitset & ~$bitset;
320			return $clone;
321			}
322
323	1		/**
324			* Produce a new set with enumerators in either this and other but not in both (this ^ (other \| other))
325	1		* @param EnumSet ...$other Other EnumSet(s) of the same enumeration to produce the union
326	1		* @return EnumSet
327	1		*/
328		View Code Duplication	public function symDiff(EnumSet $other)
			0 ignored issues – show Unused Code introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report The parameter `$other` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2016-10-01 19:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
329			{
330			$bitset = '';
331			foreach (func_get_args() as $other) {
332			if (!$other instanceof self \|\| $this->enumeration !== $other->enumeration) {
333			throw new InvalidArgumentException(sprintf(
334			"Others should be an instance of %s of the same enumeration as this %s",
335	1		__CLASS__,
336	1		$this->enumeration
337			));
338	1		}
339	1
340	1		$bitset \|= $other->bitset;
341			}
342
343			$clone = clone $this;
344			$clone->bitset = $this->bitset ^ $bitset;
345			return $clone;
346			}
347	12
348			/**
349	12		* Get ordinal numbers of the defined enumerators as array
350	12		* @return int[]
351			*/
352	12		public function getOrdinals()
353	12		{
354	12		$ordinals = array();
355			$byteLen = strlen($this->bitset);
356
357	12		for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
358	12		if ($this->bitset[$bytePos] === "\0") {
359	12		continue; // fast skip null byte
360	12		}
361	12
362	12		for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
363			if ((ord($this->bitset[$bytePos]) & (1 << $bitPos)) !== 0) {
364	12		$ordinals[] = $bytePos * 8 + $bitPos;
365			}
366			}
367			}
368
369			return $ordinals;
370			}
371	6
372			/**
373	6		* Get values of the defined enumerators as array
374	6		* @return null[]\|bool[]\|int[]\|float[]\|string[]
375	6		*/
376	6		public function getValues()
377	6		{
378			$values = array();
379			foreach ($this->getEnumerators() as $enumerator) {
380			$values[] = $enumerator->getValue();
381			}
382			return $values;
383			}
384	2
385			/**
386	2		* Get names of the defined enumerators as array
387	2		* @return string[]
388	2		*/
389	2		public function getNames()
390	2		{
391			$names = array();
392			foreach ($this->getEnumerators() as $enumerator) {
393			$names[] = $enumerator->getName();
394			}
395			return $names;
396			}
397	10
398			/**
399	10		* Get the defined enumerators as array
400	10		* @return Enum[]
401	10		*/
402	10		public function getEnumerators()
403	10		{
404	10		$enumeration = $this->enumeration;
405			$enumerators = array();
406			foreach ($this->getOrdinals() as $ord) {
407			$enumerators[] = $enumeration::getByOrdinal($ord);
408			}
409			return $enumerators;
410			}
411
412	10		/**
413			* Get binary bitset in little-endian order
414	10		*
415			* @return string
416			*/
417			public function getBinaryBitsetLe()
418			{
419			return $this->bitset;
420			}
421
422			/**
423			* Set binary bitset in little-endian order
424			*
425			* NOTE: It resets the current position of the iterator
426	6		*
427			* @param string $bitset
428	6		* @return void
429	1		* @throws InvalidArgumentException On a non string is given as Parameter
430			*/
431			public function setBinaryBitsetLe($bitset)
432	5		{
433	5		if (!is_string($bitset)) {
434			throw new InvalidArgumentException('Bitset must be a string');
435	5		}
436
437	1		$size = strlen($this->bitset);
438	5		$sizeIn = strlen($bitset);
439	1
440	1		if ($sizeIn < $size) {
441			// add "\0" if the given bitset is not long enough
442	5		$bitset .= str_repeat("\0", $size - $sizeIn);
443			} elseif ($sizeIn > $size) {
444	5		$bitset = substr($bitset, 0, $size);
445	5		}
446
447			// truncate out-of-range bits of last byte
448			$lastByteMaxOrd = $this->ordinalMax % 8;
449			if ($lastByteMaxOrd === 0) {
450			$this->bitset = $bitset;
451			} else {
452	2		$lastByte = chr($lastByteMaxOrd) & $bitset[$size - 1];
453			$this->bitset = substr($bitset, 0, -1) . $lastByte;
454	2		}
455
456			// reset the iterator position
457			$this->rewind();
458			}
459
460			/**
461			* Get binary bitset in big-endian order
462			*
463			* @return string
464			*/
465			public function getBinaryBitsetBe()
466	3		{
467			return strrev($this->bitset);
468	3		}
469	1
470			/**
471			* Set binary bitset in big-endian order
472	2		*
473	2		* NOTE: It resets the current position of the iterator
474			*
475			* @param string $bitset
476			* @return void
477			* @throws InvalidArgumentException On a non string is given as Parameter
478			*/
479			public function setBinaryBitsetBe($bitset)
480			{
481			if (!is_string($bitset)) {
482			throw new InvalidArgumentException('Bitset must be a string');
483			}
484
485			$this->setBinaryBitsetLe(strrev($bitset));
486			}
487
488			/**
489			* Get the binary bitset
490			*
491			* @return string Returns the binary bitset in big-endian order
492			* @deprecated Please use getBinaryBitsetBe() instead
493			*/
494			public function getBitset()
495			{
496			return $this->getBinaryBitsetBe();
497			}
498
499			/**
500			* Set the bitset.
501			* NOTE: It resets the current position of the iterator
502			*
503			* @param string $bitset The binary bitset in big-endian order
504			* @return void
505			* @throws InvalidArgumentException On a non string is given as Parameter
506	22		* @deprecated Please use setBinaryBitsetBe() instead
507			*/
508	22		public function setBitset($bitset)
509			{
510			$this->setBinaryBitsetBE($bitset);
511			}
512
513			/**
514			* Get a bit at the given ordinal number
515			*
516			* @param $ordinal int Ordinal number of bit to get
517	35		* @return boolean
518			*/
519	35		private function getBit($ordinal)
520	35		{
521	35		return (ord($this->bitset[(int) ($ordinal / 8)]) & 1 << ($ordinal % 8)) !== 0;
522			}
523
524			/**
525			* Set a bit at the given ordinal number
526			*
527			* @param $ordinal int Ordnal number of bit to set
528			* @return void
529	7		*/
530			private function setBit($ordinal)
531	7		{
532	7		$byte = (int) ($ordinal / 8);
533	7		$this->bitset[$byte] = $this->bitset[$byte] \| chr(1 << ($ordinal % 8));
534			}
535
536			/**
537			* Unset a bit at the given ordinal number
538			*
539			* @param $ordinal int Ordinal number of bit to unset
540			* @return void
541			*/
542			private function unsetBit($ordinal)
543			{
544			$byte = (int) ($ordinal / 8);
545			$this->bitset[$byte] = $this->bitset[$byte] & chr(~(1 << ($ordinal % 8)));
546			}
547			}
548

marc-mabe / php-enum

Push — enumset_produce ( 3d5c3d...ac9aa5 )

EnumSet::count() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like