Decoder - Code Metrics - Inspection of "Initial commit" - AlexMasterov/msgpack.php - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( dfbfc3...419bb7 )

by Alex

created 2018-03-10 18:43 UTC

Decoder C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	278
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
dl	0
loc	278
rs	5.8893
c	0
b	0
f	0
ccs	152
cts	152
cp	1
wmc	63
lcom	1
cbo	0

15 Methods

Rating	Name	Size	Complexity
A	decode()	7	1
C	parse()	71	30
A	decodeFloat32()	13	2
A	decodeFloat64()	18	2
A	decodeUint8()	8	2
A	decodeUint16()	9	2
A	decodeUint32()	11	2
A	decodeUint64()	17	3
A	decodeInt8()	10	3
A	decodeInt16()	11	3
A	decodeInt32()	13	3
B	decodeInt64()	34	3
A	decodeStr()	15	3
A	decodeArray()	9	2
A	decodeMap()	9	2

How to fix Complexity

<?php
declare(strict_types=1);

namespace MessagePack;

use MessagePack\Exception\DecodingFailed;
use const MessagePack\ORD;
use function MessagePack\{toDouble, toFloat};

final class Decoder
{
    /** @var string */
    private $data = '';

    /** @var int */
    private $offset = 0;

    public function decode(string $data)
    {
        $this->data = $data;
        $this->offset = 0;

        return $this->parse();
    }

    private function parse()
    {
        if (!isset($this->data[$this->offset])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 1);
        }

        $byte = ORD[$this->data[$this->offset++]];

        if ($byte < 0xc0) {
            // positive fixint
            if ($byte < 0x80) {
                return $byte;
            }
            // fixmap
            if ($byte < 0x90) {
                return $this->decodeMap($byte & 0xf);
            }
            // fixarray
            if ($byte < 0xa0) {
                return $this->decodeArray($byte & 0x0f);
            }
            // fixstr
            return $this->decodeStr($byte & 0x1f);
        }
        // negative fixint
        if ($byte > 0xdf) {
            return $byte - 0x100;
        }

        switch ($byte) {
            case 0xc0: return null;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xc2: return false;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xc3: return true;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // bin 8/16/32
            case 0xc4: return $this->decodeStr($this->decodeUint8());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xc5: return $this->decodeStr($this->decodeUint16());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xc6: return $this->decodeStr($this->decodeUint32());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // float 32/64
            case 0xca: return $this->decodeFloat32();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xcb: return $this->decodeFloat64();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // uint 8/16/32/64
            case 0xcc: return $this->decodeUint8();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xcd: return $this->decodeUint16();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xce: return $this->decodeUint32();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xcf: return $this->decodeUint64();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // int 8/16/32/64
            case 0xd0: return $this->decodeInt8();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xd1: return $this->decodeInt16();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xd2: return $this->decodeInt32();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xd3: return $this->decodeInt64();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // str 8/16/32
            case 0xd9: return $this->decodeStr($this->decodeUint8());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xda: return $this->decodeStr($this->decodeUint16());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xdb: return $this->decodeStr($this->decodeUint32());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // array 16/32
            case 0xdc: return $this->decodeArray($this->decodeUint16());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xdd: return $this->decodeArray($this->decodeUint32());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

            // map 16/32
            case 0xde: return $this->decodeMap($this->decodeUint16());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 0xdf: return $this->decodeMap($this->decodeUint32());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
          }


        throw DecodingFailed::unknownByteHeader($byte, $this->offset);
    }

    private function decodeFloat32(): float
    {
        if (!isset($this->data[$this->offset + 3])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 4);
        }

        $num = ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];

        return toFloat($num);
    }

    private function decodeFloat64(): float
    {
        if (!isset($this->data[$this->offset + 7])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 8);
        }

        $x = ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];

        $y = ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];

        return toDouble($y, $x);
    }

    private function decodeUint8(): int
    {
        if (!isset($this->data[$this->offset])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 1);
        }

        return ORD($this->data[$this->offset++]);
    }

    private function decodeUint16(): int
    {
        if (!isset($this->data[$this->offset + 1])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 2);
        }

        return ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];
    }

    private function decodeUint32(): int
    {
        if (!isset($this->data[$this->offset + 3])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 4);
        }

        return ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];
    }

    private function decodeUint64()
    {
        if (!isset($this->data[$this->offset + 7])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 8);
        }

        $num = (ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]]) * 0x100000000
            | ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];

        return $num > 0 ? $num : \sprintf('%u', $num);
    }

    private function decodeInt8(): int
    {
        if (!isset($this->data[$this->offset])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 1);
        }

        $num = ORD[$this->data[$this->offset++]];

        return $num & 0x80 ? $num - 0x100 : $num;
    }

    private function decodeInt16(): int
    {
        if (!isset($this->data[$this->offset + 1])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 2);
        }

        $num = ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];

        return $num & 0x8000 ? $num - 0x10000 : $num;
    }

    private function decodeInt32(): int
    {
        if (!isset($this->data[$this->offset + 3])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 4);
        }

        $num = ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] << 16
            | ORD[$this->data[$this->offset++]] << 8
            | ORD[$this->data[$this->offset++]];

        return $num & 0x80000000 ? $num - 0x100000000 : $num;
    }

    private function decodeInt64(): int
    {
        if (!isset($this->data[$this->offset + 7])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, 8);
        }

        $num = ORD[$this->data[$this->offset++]];

        $negate = ($num & 0x80) === 0x80;

        if ($negate) {
            $num = (($num ^ 0xff) * 0x100000000000000)
                | (ORD[$this->data[$this->offset++]] ^ 0xff) * 0x1000000000000
                | (ORD[$this->data[$this->offset++]] ^ 0xff) * 0x10000000000
                | (ORD[$this->data[$this->offset++]] ^ 0xff) * 0x100000000
                | (ORD[$this->data[$this->offset++]] ^ 0xff) * 0x1000000
                | (ORD[$this->data[$this->offset++]] ^ 0xff) * 0x10000
                | (ORD[$this->data[$this->offset++]] ^ 0xff) * 0x100
                | ORD[$this->data[$this->offset++]] ^ 0xff;

            return ~$num;
        }

        $num = ($num * 0x100000000000000)
            | ORD[$this->data[$this->offset++]] * 0x1000000000000
            | ORD[$this->data[$this->offset++]] * 0x10000000000
            | ORD[$this->data[$this->offset++]] * 0x100000000
            | ORD[$this->data[$this->offset++]] * 0x1000000
            | ORD[$this->data[$this->offset++]] * 0x10000
            | ORD[$this->data[$this->offset++]] * 0x100
            | ORD[$this->data[$this->offset++]];

        return $num;
    }

    private function decodeStr(int $length): string
    {
        if (0 === $length) {
            return '';
        }

        if (!isset($this->data[$this->offset + $length - 1])) {
            throw DecodingFailed::insufficientData($this->data, $this->offset, $length);
        }

        $str = \substr($this->data, $this->offset++, $length);
        $this->offset += $length;

        return $str;
    }

    private function decodeArray(int $size): array
    {
        $array = [];
        while ($size--) {
            $array[] = $this->parse();
        }

        return $array;
    }

    private function decodeMap(int $size): array
    {
        $map = [];
        while ($size--) {
            $map[$this->parse()] = $this->parse();
        }

        return $map;
    }
}


1		<?php
2		declare(strict_types=1);
3
4		namespace MessagePack;
5
6		use MessagePack\Exception\DecodingFailed;
7		use const MessagePack\ORD;
8		use function MessagePack\{toDouble, toFloat};
9
10		final class Decoder
11		{
12		/** @var string */
13		private $data = '';
14
15		/** @var int */
16		private $offset = 0;
17
18	65	public function decode(string $data)
19		{
20	65	$this->data = $data;
21	65	$this->offset = 0;
22
23	65	return $this->parse();
24		}
25
26	65	private function parse()
27		{
28	65	if (!isset($this->data[$this->offset])) {
29	1	throw DecodingFailed::insufficientData($this->data, $this->offset, 1);
30		}
31
32	64	$byte = ORD[$this->data[$this->offset++]];
33
34	64	if ($byte < 0xc0) {
35		// positive fixint
36	15	if ($byte < 0x80) {
37	11	return $byte;
38		}
39		// fixmap
40	7	if ($byte < 0x90) {

AlexMasterov / msgpack.php

Push — master ( dfbfc3...419bb7 )

Decoder C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

15 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like