BufferUnpacker::unpackI8() - Code Metrics - Inspection of "Merge pull request #9 from rybakit/memory_string_c..." - rybakit/msgpack.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 977cb6...ca93a0 )

by Eugene
created 2016-04-28 20:27 UTC
BufferUnpacker::unpackI8() A

↳ Parent: BufferUnpacker
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
c	1
b	0
f	0
dl	0
loc	11
ccs	6
cts	6
cp	1
rs	9.4285
cc	1
eloc	6
nc	1
nop	0
crap	1
<?php

/*
 * This file is part of the rybakit/msgpack.php package.
 *
 * (c) Eugene Leonovich <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace MessagePack;

use MessagePack\Exception\InsufficientDataException;
use MessagePack\Exception\IntegerOverflowException;
use MessagePack\Exception\UnpackingFailedException;
use MessagePack\TypeTransformer\Collection;

class BufferUnpacker
{
    const INT_AS_EXCEPTION = 0;
    const INT_AS_STR = 1;
    const INT_AS_GMP = 2;

    /**
     * @var int
     */
    private $intOverflowMode = self::INT_AS_EXCEPTION;

    /**
     * @var string
     */
    private $buffer = '';

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

    /**
     * @var Collection
     */
    private $transformers;

    /**
     * @param int|null $intOverflowMode
     */
    public function __construct($intOverflowMode = null)
    {
        if (null !== $intOverflowMode) {
            $this->intOverflowMode = $intOverflowMode;
        }
    }

    /**
     * @param Collection|null $transformers
     */
    public function setTransformers(Collection $transformers = null)
    {
        $this->transformers = $transformers;
    }

    /**
     * @return Collection|null
     */
    public function getTransformers()
    {
        return $this->transformers;
    }

    /**
     * @param int $intOverflowMode
     *
     * @throws \InvalidArgumentException
     */
    public function setIntOverflowMode($intOverflowMode)
    {
        if (!\in_array($intOverflowMode, [
            self::INT_AS_EXCEPTION,
            self::INT_AS_STR,
            self::INT_AS_GMP,
        ], true)) {
            throw new \InvalidArgumentException(\sprintf('Invalid integer overflow mode: %s.', $intOverflowMode));
        }

        $this->intOverflowMode = $intOverflowMode;
    }

    /**
     * @return int
     */
    public function getIntOverflowMode()
    {
        return $this->intOverflowMode;
    }

    /**
     * @param string $data
     *
     * @return $this
     */
    public function append($data)
    {
        $this->buffer .= $data;

        return $this;
    }

    /**
     * @param string $buffer
     *
     * @return $this
     */
    public function reset($buffer = '')
    {
        $this->buffer = $buffer;
        $this->offset = 0;

        return $this;
    }

    /**
     * @return array
     */
    public function tryUnpack()
    {
        $data = [];
        $offset = $this->offset;

        try {
            do {
                $data[] = $this->unpack();
                $offset = $this->offset;
            } while (isset($this->buffer[$this->offset]));
        } catch (InsufficientDataException $e) {
            $this->offset = $offset;
        }

        if ($this->offset) {
            $this->buffer = isset($this->buffer[$this->offset]) ? \substr($this->buffer, $this->offset) : '';
            $this->offset = 0;
        }

        return $data;
    }

    /**
     * @return mixed
     *
     * @throws UnpackingFailedException
     */
    public function unpack()
    {
        $this->ensureLength(1);

        $c = \ord($this->buffer[$this->offset]);
        $this->offset += 1;

        // fixint
        if ($c <= 0x7f) {
            return $c;
        }
        // fixstr
        if ($c >= 0xa0 && $c <= 0xbf) {
            return $this->unpackStr($c & 0x1f);
        }
        // fixarray
        if ($c >= 0x90 && $c <= 0x9f) {
            return $this->unpackArray($c & 0xf);
        }
        // fixmap
        if ($c >= 0x80 && $c <= 0x8f) {
            return $this->unpackMap($c & 0xf);
        }
        // negfixint
        if ($c >= 0xe0) {
            return $c - 256;
        }

        switch ($c) {
            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;

            // MP_BIN
            case 0xc4: return $this->unpackStr($this->unpackU8());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

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

    doSomethingElse(); //wrong
    break;

            // MP_FLOAT
            case 0xca: return $this->unpackFloat();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

    doSomethingElse(); //wrong
    break;

            // MP_UINT
            case 0xcc: return $this->unpackU8();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

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

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

    doSomethingElse(); //wrong
    break;

            // MP_INT
            case 0xd0: return $this->unpackI8();
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

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

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

    doSomethingElse(); //wrong
    break;

            // MP_STR
            case 0xd9: return $this->unpackStr($this->unpackU8());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

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

    doSomethingElse(); //wrong
    break;

            // MP_ARRAY
            case 0xdc: return $this->unpackArray($this->unpackU16());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

    doSomethingElse(); //wrong
    break;

            // MP_MAP
            case 0xde: return $this->unpackMap($this->unpackU16());
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

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

    doSomethingElse(); //wrong
    break;

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

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

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

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

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

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

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

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

    doSomethingElse(); //wrong
    break;
        }

        throw new UnpackingFailedException(\sprintf('Unknown code: 0x%x.', $c));
    }

    private function unpackU8()
    {
        $this->ensureLength(1);

        $num = $this->buffer[$this->offset];
        $this->offset += 1;

        $num = \unpack('C', $num);

        return $num[1];
    }

    private function unpackU16()

    {
        $this->ensureLength(2);

        $num = $this->buffer[$this->offset].$this->buffer[$this->offset + 1];
        $this->offset += 2;

        $num = \unpack('n', $num);

        return $num[1];
    }

    private function unpackU32()

    {
        $this->ensureLength(4);

        $num = \substr($this->buffer, $this->offset, 4);
        $this->offset += 4;

        $num = \unpack('N', $num);

        return $num[1];
    }

    private function unpackU64()
    {
        $this->ensureLength(8);

        $num = \substr($this->buffer, $this->offset, 8);
        $this->offset += 8;

        //$num = \unpack('J', $num);


        $set = \unpack('N2', $num);
        $value = $set[1] << 32 | $set[2];

        // PHP does not support unsigned integers.
        // If a number is bigger than 2^63, it will be interpreted as a float.
        // @link http://php.net/manual/en/language.types.integer.php#language.types.integer.overflow

        return ($value < 0) ? $this->handleIntOverflow($value) : $value;
    }

    private function unpackI8()
    {
        $this->ensureLength(1);

        $num = $this->buffer[$this->offset];
        $this->offset += 1;

        $num = \unpack('c', $num);

        return $num[1];
    }

    private function unpackI16()

    {
        $this->ensureLength(2);

        $num = $this->buffer[$this->offset].$this->buffer[$this->offset + 1];
        $this->offset += 2;

        $num = \unpack('s', \strrev($num));

        return $num[1];
    }

    private function unpackI32()
    {
        $this->ensureLength(4);

        $num = \substr($this->buffer, $this->offset, 4);
        $this->offset += 4;

        $num = \unpack('i', \strrev($num));

        return $num[1];
    }

    private function unpackI64()

    {
        $this->ensureLength(8);

        $num = \substr($this->buffer, $this->offset, 8);
        $this->offset += 8;

        $set = \unpack('N2', $num);

        return $set[1] << 32 | $set[2];
    }

    private function unpackFloat()
    {
        $this->ensureLength(4);

        $num = \substr($this->buffer, $this->offset, 4);
        $this->offset += 4;

        $num = \unpack('f', \strrev($num));

        return $num[1];
    }

    private function unpackDouble()
    {
        $this->ensureLength(8);

        $num = \substr($this->buffer, $this->offset, 8);
        $this->offset += 8;

        $num = \unpack('d', \strrev($num));

        return $num[1];
    }

    private function unpackStr($length)
    {
        if (!$length) {
            return '';
        }

        $this->ensureLength($length);

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

        return $str;
    }

    private function unpackArray($size)
    {
        $array = [];

        for ($i = $size; $i; $i--) {
            $array[] = $this->unpack();
        }

        return $array;
    }

    private function unpackMap($size)
    {
        $map = [];

        for ($i = $size; $i; $i--) {
            $key = $this->unpack();
            $value = $this->unpack();

            $map[$key] = $value;
        }

        return $map;
    }

    private function unpackExt($length)
    {
        $this->ensureLength($length);

        $type = $this->unpackI8();
        $data = \substr($this->buffer, $this->offset, $length);

        if ($this->transformers && $transformer = $this->transformers->find($type)) {
            return $transformer->reverseTransform($this->unpack());
        }

        $this->offset += $length;

        return new Ext($type, $data);
    }

    private function ensureLength($length)
    {
        if (!isset($this->buffer[$this->offset + $length - 1])) {
            throw new InsufficientDataException($length, \strlen($this->buffer) - $this->offset);
        }
    }

    private function handleIntOverflow($value)
    {
        if (self::INT_AS_STR === $this->intOverflowMode) {
            return \sprintf('%u', $value);
        }
        if (self::INT_AS_GMP === $this->intOverflowMode) {
            return \gmp_init(\sprintf('%u', $value));
        }

        throw new IntegerOverflowException($value);
    }
}

1			<?php
2
3			/*
4			* This file is part of the rybakit/msgpack.php package.
5			*
6			* (c) Eugene Leonovich <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace MessagePack;
13
14			use MessagePack\Exception\InsufficientDataException;
15			use MessagePack\Exception\IntegerOverflowException;
16			use MessagePack\Exception\UnpackingFailedException;
17			use MessagePack\TypeTransformer\Collection;
18
19			class BufferUnpacker
20			{
21			const INT_AS_EXCEPTION = 0;
22			const INT_AS_STR = 1;
23			const INT_AS_GMP = 2;
24
25			/**
26			* @var int
27			*/
28			private $intOverflowMode = self::INT_AS_EXCEPTION;
29
30			/**
31			* @var string
32			*/
33			private $buffer = '';
34
35			/**
36			* @var int
37			*/
38			private $offset = 0;
39
40			/**
rybakit / msgpack.php

Push — master ( 977cb6...ca93a0 )

BufferUnpacker::unpackI8() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
