Decoder::decodeUint16() - Code Metrics - Inspection of "Create specific exceptions" - AlexMasterov/msgpack.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c630a6...61819f )

by Alex

created 2018-03-13 06:45 UTC

Decoder::decodeUint16() A

↳ Parent: Decoder

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2.032

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	0
dl	0
loc	9
ccs	4
cts	5
cp	0.8
crap	2.032
rs	9.6666
c	0
b	0
f	0

<?php
declare(strict_types=1);

namespace MessagePack;

use MessagePack\{
    Exception\InsufficientData,
    Exception\UnknownByteHeader,
    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 InsufficientData::fromOffset($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/2/4/8/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 UnknownByteHeader::fromOffset($byte, $this->offset);
    }

    private function decodeFloat32(): float
    {
        if (!isset($this->data[$this->offset + 3])) {
            throw InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($this->data, $this->offset, 1);
        }

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

    private function decodeUint16(): int
    {
        if (!isset($this->data[$this->offset + 1])) {
            throw InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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 InsufficientData::fromOffset($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\{
7		Exception\InsufficientData,
8		Exception\UnknownByteHeader,
9		Ext
		0 ignored issues – show Bug introduced 2018-03-13 07:22 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...
10		};
11		use const MessagePack\ORD;
12		use function MessagePack\{toDouble, toFloat};
13		use function sprintf;
14		use function substr;
15
16		final class Decoder
17		{
18		/** @var string */
19		private $data = '';
20
21		/** @var int */
22		private $offset = 0;
23
24	62	public function decode(string $data)
25		{
26	62	$this->data = $data;
27	62	$this->offset = 0;
28
29	62	return $this->parse();
30		}
31
32	62	private function parse()
33		{
34	62	if (!isset($this->data[$this->offset])) {
35		throw InsufficientData::fromOffset($this->data, $this->offset, 1);
36		}
37
38	62	$byte = ORD[$this->data[$this->offset++]];
39

AlexMasterov / msgpack.php

Push — master ( c630a6...61819f )

Decoder::decodeUint16() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like