Parser::getBuffer() - Code Metrics - Inspection of "Require Buffer as Parser argument" - Bit-Wasp/buffertools-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#71)

by thomas

created 2017-12-30 00:25 UTC

Parser::getBuffer() A

↳ Parent: Parser

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

declare(strict_types=1);

namespace BitWasp\Buffertools;

use BitWasp\Buffertools\Exceptions\ParserOutOfRange;

class Parser
{
    /**
     * @var string
     */
    private $string = '';

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

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

    /**
     * Instantiate class, optionally taking Buffer or HEX.
     *
     * @param BufferInterface $input
     */
    public function __construct(BufferInterface $input = null)
    {
        if ($input instanceof BufferInterface) {
            $this->string = $input->getBinary();
            $this->size = $input->getSize();
        }
    }

    /**
     * Get the position pointer of the parser - ie, how many bytes from 0
     *
     * @return int
     */
    public function getPosition(): int
    {
        return $this->position;
    }

    /**
     * Get the total size of the parser
     *
     * @return int
     */
    public function getSize()
    {
        return $this->size;
    }

    /**
     * Parse $bytes bytes from the string, and return the obtained buffer
     *
     * @param  int $numBytes
     * @param  bool $flipBytes
     * @return BufferInterface
     * @throws \Exception
     */
    public function readBytes(int $numBytes, bool $flipBytes = false): BufferInterface
    {
        $string = substr($this->string, $this->getPosition(), $numBytes);
        $length = strlen($string);

        if ($length === 0) {
            throw new ParserOutOfRange('Could not parse string of required length (empty)');
        } elseif ($length < $numBytes) {
            throw new ParserOutOfRange('Could not parse string of required length (too short)');
        }

        $this->position += $numBytes;

        if ($flipBytes) {
            $string = Buffertools::flipBytes($string);
            /** @var string $string */
        }

        return new Buffer($string, $length);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Write $data as $bytes bytes. Can be flipped if needed.
     *
     * @param  integer $numBytes - number of bytes to write
     * @param  SerializableInterface|BufferInterface|string $data - buffer, serializable or hex
     * @param  bool $flipBytes
     * @return Parser
     */
    public function writeBytes(int $numBytes, $data, bool $flipBytes = false): Parser
    {
        // Treat $data to ensure it's a buffer, with the correct size
        if ($data instanceof SerializableInterface) {
            $data = $data->getBuffer();
        }

        if (is_string($data)) {
            // Convert to a buffer
            $data = Buffer::hex($data, $numBytes);
        } else if (!($data instanceof BufferInterface)) {
            throw new \RuntimeException('Invalid data passed to Parser::writeBytes');
        }

        $this->writeBuffer($numBytes, $data, $flipBytes);

        return $this;
    }

    /**
     * Write $data as $bytes bytes. Can be flipped if needed.
     *
     * @param  integer $numBytes
     * @param  string $data
     * @param  bool $flipBytes
     * @return Parser
     */
    public function writeRawBinary(int $numBytes, string $data, bool $flipBytes = false): Parser
    {
        return $this->writeBuffer($numBytes, new Buffer($data, $numBytes), $flipBytes);
    }

    /**
     * @param BufferInterface $buffer
     * @param bool $flipBytes
     * @param int $numBytes
     * @return Parser
     */
    public function writeBuffer(int $numBytes, BufferInterface $buffer, bool $flipBytes = false): Parser
    {
        // only create a new buffer if the size does not match
        if ($buffer->getSize() != $numBytes) {
            $buffer = new Buffer($buffer->getBinary(), $numBytes);
        }

        $this->appendBuffer($buffer, $flipBytes);

        return $this;
    }

    /**
     * @param BufferInterface $buffer
     * @param bool $flipBytes
     * @return Parser
     */
    public function appendBuffer(BufferInterface $buffer, bool $flipBytes = false): Parser
    {
        $this->appendBinary($buffer->getBinary(), $flipBytes);
        return $this;
    }

    /**
     * @param string $binary
     * @param bool $flipBytes
     * @return Parser
     */
    public function appendBinary(string $binary, bool $flipBytes = false): Parser
    {
        if ($flipBytes) {
            $binary = Buffertools::flipBytes($binary);
        }

        $this->string .= $binary;
        $this->size += strlen($binary);
        return $this;
    }

    /**
     * Take an array containing serializable objects.
     * @param SerializableInterface[]|BufferInterface[] $serializable
     * @return Parser
     */
    public function writeArray(array $serializable): Parser
    {
        $parser = new Parser(Buffertools::numToVarInt(count($serializable)));
        foreach ($serializable as $object) {
            if ($object instanceof SerializableInterface) {
                $object = $object->getBuffer();
            }

            if ($object instanceof BufferInterface) {
                $parser->writeBytes($object->getSize(), $object);
            } else {
                throw new \RuntimeException('Input to writeArray must be Buffer[], or SerializableInterface[]');
            }
        }

        $this->string .= $parser->getBuffer()->getBinary();
        $this->size += $parser->getSize();

        return $this;
    }

    /**
     * Return the string as a buffer
     *
     * @return BufferInterface
     */
    public function getBuffer(): BufferInterface
    {
        return new Buffer($this->string, null);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BitWasp\Buffertools;
6
7		use BitWasp\Buffertools\Exceptions\ParserOutOfRange;
8
9		class Parser
10		{
11		/**
12		* @var string
13		*/
14		private $string = '';
15
16		/**
17		* @var int
18		*/
19		private $size = 0;
20
21		/**
22		* @var int
23		*/
24		private $position = 0;
25
26		/**
27		* Instantiate class, optionally taking Buffer or HEX.
28		*
29		* @param BufferInterface $input
30		*/
31	164	public function __construct(BufferInterface $input = null)
32		{
33	164	if ($input instanceof BufferInterface) {
34	152	$this->string = $input->getBinary();
35	152	$this->size = $input->getSize();
36		}
37	164	}
38
39		/**
40		* Get the position pointer of the parser - ie, how many bytes from 0
41		*
42		* @return int
43		*/
44	148	public function getPosition(): int
45		{
46	148	return $this->position;
47		}
48
49		/**
50		* Get the total size of the parser
51		*
52		* @return int
53		*/
54	16	public function getSize()
55		{
56	16	return $this->size;
57		}
58
59		/**
60		* Parse $bytes bytes from the string, and return the obtained buffer
61		*
62		* @param int $numBytes
63		* @param bool $flipBytes
64		* @return BufferInterface
65		* @throws \Exception
66		*/
67	146	public function readBytes(int $numBytes, bool $flipBytes = false): BufferInterface
68		{
69	146	$string = substr($this->string, $this->getPosition(), $numBytes);
70	146	$length = strlen($string);
71
72	146	if ($length === 0) {
73	4	throw new ParserOutOfRange('Could not parse string of required length (empty)');
74	144	} elseif ($length < $numBytes) {
75	2	throw new ParserOutOfRange('Could not parse string of required length (too short)');
76		}
77
78	142	$this->position += $numBytes;
79
80	142	if ($flipBytes) {
81	2	$string = Buffertools::flipBytes($string);
82		/** @var string $string */
83		}
84
85	142	return new Buffer($string, $length);
		0 ignored issues – show Bug introduced 2017-12-25 16:39 UTC by Report Bug Copy Issue Report It seems like `$string` defined by `\BitWasp\Buffertools\Buf...ols::flipBytes($string)` on line `81` can also be of type `object<BitWasp\Buffertools\Buffer>`; however, `BitWasp\Buffertools\Buffer::__construct()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
86		}
87
88		/**
89		* Write $data as $bytes bytes. Can be flipped if needed.
90		*
91		* @param integer $numBytes - number of bytes to write
92		* @param SerializableInterface\|BufferInterface\|string $data - buffer, serializable or hex
93		* @param bool $flipBytes
94		* @return Parser
95		*/
96	10	public function writeBytes(int $numBytes, $data, bool $flipBytes = false): Parser
97		{
98		// Treat $data to ensure it's a buffer, with the correct size
99	10	if ($data instanceof SerializableInterface) {
100		$data = $data->getBuffer();
101		}
102
103	10	if (is_string($data)) {
104		// Convert to a buffer
105		$data = Buffer::hex($data, $numBytes);
106	10	} else if (!($data instanceof BufferInterface)) {
107		throw new \RuntimeException('Invalid data passed to Parser::writeBytes');
108		}
109
110	10	$this->writeBuffer($numBytes, $data, $flipBytes);
111
112	10	return $this;
113		}
114
115		/**
116		* Write $data as $bytes bytes. Can be flipped if needed.
117		*
118		* @param integer $numBytes
119		* @param string $data
120		* @param bool $flipBytes
121		* @return Parser
122		*/
123		public function writeRawBinary(int $numBytes, string $data, bool $flipBytes = false): Parser
124		{
125		return $this->writeBuffer($numBytes, new Buffer($data, $numBytes), $flipBytes);
126		}
127
128		/**
129		* @param BufferInterface $buffer
130		* @param bool $flipBytes
131		* @param int $numBytes
132		* @return Parser
133		*/
134	10	public function writeBuffer(int $numBytes, BufferInterface $buffer, bool $flipBytes = false): Parser
135		{
136		// only create a new buffer if the size does not match
137	10	if ($buffer->getSize() != $numBytes) {
138	4	$buffer = new Buffer($buffer->getBinary(), $numBytes);
139		}
140
141	10	$this->appendBuffer($buffer, $flipBytes);
142
143	10	return $this;
144		}
145
146		/**
147		* @param BufferInterface $buffer
148		* @param bool $flipBytes
149		* @return Parser
150		*/
151	10	public function appendBuffer(BufferInterface $buffer, bool $flipBytes = false): Parser
152		{
153	10	$this->appendBinary($buffer->getBinary(), $flipBytes);
154	10	return $this;
155		}
156
157		/**
158		* @param string $binary
159		* @param bool $flipBytes
160		* @return Parser
161		*/
162	10	public function appendBinary(string $binary, bool $flipBytes = false): Parser
163		{
164	10	if ($flipBytes) {
165	4	$binary = Buffertools::flipBytes($binary);
166		}
167
168	10	$this->string .= $binary;
169	10	$this->size += strlen($binary);
170	10	return $this;
171		}
172
173		/**
174		* Take an array containing serializable objects.
175		* @param SerializableInterface[]\|BufferInterface[] $serializable
176		* @return Parser
177		*/
178	2	public function writeArray(array $serializable): Parser
179		{
180	2	$parser = new Parser(Buffertools::numToVarInt(count($serializable)));
181	2	foreach ($serializable as $object) {
182	2	if ($object instanceof SerializableInterface) {
183		$object = $object->getBuffer();
184		}
185
186	2	if ($object instanceof BufferInterface) {
187	2	$parser->writeBytes($object->getSize(), $object);
188		} else {
189	2	throw new \RuntimeException('Input to writeArray must be Buffer[], or SerializableInterface[]');
190		}
191		}
192
193	2	$this->string .= $parser->getBuffer()->getBinary();
194	2	$this->size += $parser->getSize();
195
196	2	return $this;
197		}
198
199		/**
200		* Return the string as a buffer
201		*
202		* @return BufferInterface
203		*/
204	16	public function getBuffer(): BufferInterface
205		{
206	16	return new Buffer($this->string, null);
207		}
208		}
209

Bit-Wasp / buffertools-php

Pull Request — master (#71)

Parser::getBuffer() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like