BitWasp\Buffertools\Parser

Complexity

Total Complexity

21

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	getPosition()	0	4	1
A	readBytes()	0	19	4
A	writeBytes()	0	21	4
A	writeRawBinary()	0	4	1
A	writeBuffer()	0	14	3
A	writeArray()	0	19	4
A	getBuffer()	0	4	1

<?php

namespace BitWasp\Buffertools;

use BitWasp\Buffertools\Exceptions\ParserOutOfRange;
use Mdanter\Ecc\EccFactory;
use Mdanter\Ecc\Math\GmpMathInterface;

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

    /**
     * @var \Mdanter\Ecc\Math\GmpMathInterface
     */
    private $math;

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

    /**
     * Instantiate class, optionally taking Buffer or HEX.
     *
     * @param null|string|BufferInterface $input
     * @param GmpMathInterface|null $math
     */
    public function __construct($input = null, GmpMathInterface $math = null)
    {
        $this->math = $math ?: EccFactory::getAdapter();

        if (!$input instanceof BufferInterface) {
            $input = Buffer::hex($input, null, $this->math);
        }

        $this->string = $input->getBinary();
        $this->position = 0;
    }

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

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

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

        $this->position += $bytes;

        if ($flipBytes) {
            $string = Buffertools::flipBytes($string);
        }

        return new Buffer($string, $length, $this->math);

It seems like $string defined by \BitWasp\Buffertools\Buffertools::flipBytes($string) on line 76 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?

    }

    /**
     * Write $data as $bytes bytes. Can be flipped if needed.
     *
     * @param  integer $bytes
     * @param  $data
     * @param  bool $flipBytes
     * @return $this
     */
    public function writeBytes($bytes, $data, $flipBytes = false)
    {
        // Treat $data to ensure it's a buffer, with the correct size
        if ($data instanceof SerializableInterface) {
            $data = $data->getBuffer();
        }

        if ($data instanceof BufferInterface) {
            // only create a new buffer if the size does not match
            if ($data->getSize() != $bytes) {
                $data = new Buffer($data->getBinary(), $bytes, $this->math);
            }
        } else {
            // Convert to a buffer
            $data = Buffer::hex($data, $bytes, $this->math);
        }

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

        return $this;
    }

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

    /**
     * @param BufferInterface $buffer
     * @param bool $flipBytes
     * @param int $bytes
     * @return $this
     */
    public function writeBuffer($bytes, BufferInterface $buffer, $flipBytes = false)
    {
        $size = $buffer->getSize();
        if ($bytes > $size) {
            throw new \RuntimeException('Bytes is greater than Buffer size');
        }

        if ($flipBytes) {
            $buffer = $buffer->flip();
        }

        $this->string .= $buffer->getBinary();
        return $this;
    }

    /**
     * Take an array containing serializable objects.
     * @param SerializableInterface[]|Buffer[]
     * @return $this
     */
    public function writeArray($serializable)
    {
        $parser = new Parser(Buffertools::numToVarInt(count($serializable)), $this->math);
        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();

        return $this;
    }

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