Decoder::decodeExt() - Code Metrics - Inspection of "Add support Ext format family" - AlexMasterov/msgpack.php - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 68fc3d...8f864d )

by Alex

created 2018-03-11 23:49 UTC

Decoder::decodeExt() A

↳ Parent: Decoder

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	0
loc	13
ccs	7
cts	7
cp	1
crap	2
rs	9.4285
c	0
b	0
f	0

<?php
declare(strict_types=1);

namespace MessagePack;

use MessagePack\{Exception\DecodingFailed, Ext};
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use const MessagePack\ORD;
use function MessagePack\{toDouble, toFloat};
use function sprintf;
use function substr;

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;

            // fixext 1-16
            case 0xd4: return $this->decodeExt(1);
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

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

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

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

    doSomethingElse(); //wrong
    break;

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

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

    doSomethingElse(); //wrong
    break;
            case 0xc9: return $this->decodeExt($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 ? sprintf('%u', $num) : $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;
    }

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

        $type = $this->decodeInt8();

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

        return Ext::make($type, $data);
    }
}


1		<?php
2		declare(strict_types=1);
3
4		namespace MessagePack;
5
6		use MessagePack\{Exception\DecodingFailed, Ext};
		0 ignored issues – show Bug introduced 2018-03-11 23:51 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `MessagePack\Ext`. Let’s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let’s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
7		use const MessagePack\ORD;
8		use function MessagePack\{toDouble, toFloat};
9		use function sprintf;
10		use function substr;
11
12		final class Decoder
13		{
14		/** @var string */
15		private $data = '';
16
17		/** @var int */
18		private $offset = 0;
19
20	82	public function decode(string $data)
21		{
22	82	$this->data = $data;
23	82	$this->offset = 0;
24
25	82	return $this->parse();
26		}
27
28	82	private function parse()
29		{
30	82	if (!isset($this->data[$this->offset])) {
31	1	throw DecodingFailed::insufficientData($this->data, $this->offset, 1);
32		}
33
34	81	$byte = ORD[$this->data[$this->offset++]];
35
36	81	if ($byte < 0xc0) {
37		// positive fixint
38	15	if ($byte < 0x80) {
39	11	return $byte;

AlexMasterov / msgpack.php

Push — master ( 68fc3d...8f864d )

Decoder::decodeExt() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like