EnumSet::setBinaryBitsetLe() - Code Metrics - Inspection of "fixes #71: fixed truncating left over bits of last..." - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — hotfix/71 ( 07494a )

by Marc

created 2016-10-02 18:19 UTC

EnumSet::setBinaryBitsetLe() B

↳ Parent: EnumSet

Complexity

Conditions	5
Paths	7

Size

Total Lines	28
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	5

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	28
ccs	18
cts	18
cp	1
rs	8.439
cc	5
eloc	16
nc	7
nop	1
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()
    {
        $cnt = 0;
        $ord = 0;

        while ($ord !== $this->ordinalMax) {
            if ($this->getBit($ord++)) {
                ++$cnt;
            }
        }

        return $cnt;
    }

    /**
     * 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;
    }

    /**
     * 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) & substr($bitset, -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	43		public function __construct($enumeration)
49			{
50	43	View Code Duplication	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	42		$this->enumeration = $enumeration;
58	42		$this->ordinalMax = count($enumeration::getConstants());
59
60			// init the bitset with zeros
61	42		$this->bitset = str_repeat("\0", ceil($this->ordinalMax / 8));
62	42		}
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	32		public function attach($enumerator)
90			{
91	32		$enumeration = $this->enumeration;
92	32		$this->setBit($enumeration::get($enumerator)->getOrdinal());
93	32		}
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	17		public function next()
149			{
150			do {
151	17		if (++$this->ordinal >= $this->ordinalMax) {
152	4		$this->ordinal = $this->ordinalMax;
153	4		return;
154			}
155	17		} while (!$this->getBit($this->ordinal));
156	17		}
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	11		public function rewind()
164			{
165	11		if (trim($this->bitset, "\0") !== '') {
166	11		$this->ordinal = -1;
167	11		$this->next();
168	11		} else {
169	1		$this->ordinal = 0;
170			}
171	11		}
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		$cnt = 0;
191	11		$ord = 0;
192
193	11		while ($ord !== $this->ordinalMax) {
194	10		if ($this->getBit($ord++)) {
195	10		++$cnt;
196	10		}
197	10		}
198
199	11		return $cnt;
200			}
201
202			/**
203			* Check if this EnumSet is the same as other
204			* @param EnumSet $other
205			* @return bool
206			*/
207	2		public function isEqual(EnumSet $other)
208			{
209	2		return $this->getEnumeration() === $other->getEnumeration()
210	2		&& $this->getBinaryBitsetLe() === $other->getBinaryBitsetLe();
211			}
212
213			/**
214			* Check if this EnumSet is a subset of other
215			* @param EnumSet $other
216			* @return bool
217			*/
218	4	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...
219			{
220	4		if ($this->getEnumeration() !== $other->getEnumeration()) {
221	1		return false;
222			}
223
224	3		$thisBitset = $this->getBinaryBitsetLe();
225	3		return ($thisBitset & $other->getBinaryBitsetLe()) === $thisBitset;
226			}
227
228			/**
229			* Check if this EnumSet is a superset of other
230			* @param EnumSet $other
231			* @return bool
232			*/
233	4	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...
234			{
235	4		if ($this->getEnumeration() !== $other->getEnumeration()) {
236	1		return false;
237			}
238
239	3		$thisBitset = $this->getBinaryBitsetLe();
240	3		return ($thisBitset \| $other->getBinaryBitsetLe()) === $thisBitset;
241			}
242
243			/**
244			* Get ordinal numbers of the defined enumerators as array
245			* @return int[]
246			*/
247	8		public function getOrdinals()
248			{
249	8		$ordinals = array();
250	8		$byteLen = strlen($this->bitset);
251
252	8		for ($bytePos = 0; $bytePos < $byteLen; ++$bytePos) {
253	8		if ($this->bitset[$bytePos] === "\0") {
254	8		continue; // fast skip null byte
255			}
256
257	8		for ($bitPos = 0; $bitPos < 8; ++$bitPos) {
258	8		if ((ord($this->bitset[$bytePos]) & (1 << $bitPos)) !== 0) {
259	8		$ordinals[] = $bytePos * 8 + $bitPos;
260	8		}
261	8		}
262	8		}
			0 ignored issues – show Coding Style introduced 2016-09-30 08:32 UTC by Report Bug Copy Issue Report Closing brace indented incorrectly; expected 4 spaces, found 8 Loading history...
263
264	8		return $ordinals;
265			}
266
267			/**
268			* Get values of the defined enumerators as array
269			* @return null[]\|bool[]\|int[]\|float[]\|string[]
270			*/
271	2		public function getValues()
272			{
273	2		$values = array();
274	2		foreach ($this->getEnumerators() as $enumerator) {
275	2		$values[] = $enumerator->getValue();
276	2		}
277	2		return $values;
278			}
279
280			/**
281			* Get names of the defined enumerators as array
282			* @return string[]
283			*/
284	2		public function getNames()
285			{
286	2		$names = array();
287	2		foreach ($this->getEnumerators() as $enumerator) {
288	2		$names[] = $enumerator->getName();
289	2		}
290	2		return $names;
291			}
292
293			/**
294			* Get the defined enumerators as array
295			* @return Enum[]
296			*/
297	6		public function getEnumerators()
298			{
299	6		$enumeration = $this->enumeration;
300	6		$enumerators = array();
301	6		foreach ($this->getOrdinals() as $ord) {
302	6		$enumerators[] = $enumeration::getByOrdinal($ord);
303	6		}
304	6		return $enumerators;
305			}
306
307			/**
308			* Get binary bitset in little-endian order
309			*
310			* @return string
311			*/
312	11		public function getBinaryBitsetLe()
313			{
314	11		return $this->bitset;
315			}
316
317			/**
318			* Set binary bitset in little-endian order
319			*
320			* NOTE: It resets the current position of the iterator
321			*
322			* @param string $bitset
323			* @return void
324			* @throws InvalidArgumentException On a non string is given as Parameter
325			*/
326	7		public function setBinaryBitsetLe($bitset)
327			{
328	7		if (!is_string($bitset)) {
329	1		throw new InvalidArgumentException('Bitset must be a string');
330			}
331
332	6		$size = strlen($this->bitset);
333	6		$sizeIn = strlen($bitset);
334
335	6		if ($sizeIn < $size) {
336			// add "\0" if the given bitset is not long enough
337	1		$bitset .= str_repeat("\0", $size - $sizeIn);
338	6		} elseif ($sizeIn > $size) {
339	2		$bitset = substr($bitset, 0, $size);
340	2		}
341
342			// truncate out-of-range bits of last byte
343	6		$lastByteMaxOrd = $this->ordinalMax % 8;
344	6		if ($lastByteMaxOrd === 0) {
345	1		$this->bitset = $bitset;
346	1		} else {
347	5		$lastByte = chr($lastByteMaxOrd) & substr($bitset, -1);
348	5		$this->bitset = substr($bitset, 0, -1) . $lastByte;
349			}
350
351			// reset the iterator position
352	6		$this->rewind();
353	6		}
354
355			/**
356			* Get binary bitset in big-endian order
357			*
358			* @return string
359			*/
360	2		public function getBinaryBitsetBe()
361			{
362	2		return strrev($this->bitset);
363			}
364
365			/**
366			* Set binary bitset in big-endian order
367			*
368			* NOTE: It resets the current position of the iterator
369			*
370			* @param string $bitset
371			* @return void
372			* @throws InvalidArgumentException On a non string is given as Parameter
373			*/
374	3		public function setBinaryBitsetBe($bitset)
375			{
376	3		if (!is_string($bitset)) {
377	1		throw new InvalidArgumentException('Bitset must be a string');
378			}
379
380	2		$this->setBinaryBitsetLe(strrev($bitset));
381	2		}
382
383			/**
384			* Get the binary bitset
385			*
386			* @return string Returns the binary bitset in big-endian order
387			* @deprecated Please use getBinaryBitsetBe() instead
388			*/
389			public function getBitset()
390			{
391			return $this->getBinaryBitsetBe();
392			}
393
394			/**
395			* Set the bitset.
396			* NOTE: It resets the current position of the iterator
397			*
398			* @param string $bitset The binary bitset in big-endian order
399			* @return void
400			* @throws InvalidArgumentException On a non string is given as Parameter
401			* @deprecated Please use setBinaryBitsetBe() instead
402			*/
403			public function setBitset($bitset)
404			{
405			$this->setBinaryBitsetBE($bitset);
406			}
407
408			/**
409			* Get a bit at the given ordinal number
410			*
411			* @param $ordinal int Ordinal number of bit to get
412			* @return boolean
413			*/
414	23		private function getBit($ordinal)
415			{
416	23		return (ord($this->bitset[(int) ($ordinal / 8)]) & 1 << ($ordinal % 8)) !== 0;
417			}
418
419			/**
420			* Set a bit at the given ordinal number
421			*
422			* @param $ordinal int Ordnal number of bit to set
423			* @return void
424			*/
425	32		private function setBit($ordinal)
426			{
427	32		$byte = (int) ($ordinal / 8);
428	32		$this->bitset[$byte] = $this->bitset[$byte] \| chr(1 << ($ordinal % 8));
429	32		}
430
431			/**
432			* Unset a bit at the given ordinal number
433			*
434			* @param $ordinal int Ordinal number of bit to unset
435			* @return void
436			*/
437	7		private function unsetBit($ordinal)
438			{
439	7		$byte = (int) ($ordinal / 8);
440	7		$this->bitset[$byte] = $this->bitset[$byte] & chr(~(1 << ($ordinal % 8)));
441	7		}
442			}
443

marc-mabe / php-enum

Push — hotfix/71 ( 07494a )

EnumSet::setBinaryBitsetLe() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like