Response::__construct() - Code Metrics - pear2/Net_RouterOS - Measure and Improve Code Quality continuously with Scrutinizer

Response::__construct() C
last analyzed 2025-03-03 12:38 UTC

↳ Parent: Response
Complexity

Conditions	14
Paths	45
Size

Total Lines	61
Code Lines	43
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	1	Features	0
Metric	Value
cc	14
eloc	43
c	3
b	1
f	0
nc	45
nop	5
dl	0
loc	61
rs	6.2666
How to fix Long Method Complexity

<?php

/**
 * ~~summary~~
 *
 * ~~description~~
 *
 * PHP version 5
 *
 * @category  Net
 * @package   PEAR2_Net_RouterOS
 * @author    Vasil Rangelov <[email protected]>
 * @copyright 2011 Vasil Rangelov
 * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
 * @version   GIT: $Id$
 * @link      http://pear2.php.net/PEAR2_Net_RouterOS
 */
/**
 * The namespace declaration.
 */
namespace PEAR2\Net\RouterOS;

/**
 * Refers to transmitter direction constants.
 */
use PEAR2\Net\Transmitter as T;

/**
 * Locks are released upon any exception from anywhere.
 */
use Exception as E;

/**
 * Represents a RouterOS response.
 *
 * @category Net
 * @package  PEAR2_Net_RouterOS
 * @author   Vasil Rangelov <[email protected]>
 * @license  http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
 * @link     http://pear2.php.net/PEAR2_Net_RouterOS
 */
class Response extends Message
{

    /**
     * The last response for a request.
     */
    const TYPE_FINAL = '!done';

    /**
     * A response with data.
     */
    const TYPE_DATA = '!re';

    /**
     * A response with empty data (from RouterOS 7.18).
     */
    const TYPE_EMPTY = '!empty';

    /**
     * A response signifying error.
     */
    const TYPE_ERROR = '!trap';

    /**
     * A response signifying a fatal error, due to which the connection would be
     * terminated.
     */
    const TYPE_FATAL = '!fatal';

    /**
     * An array of unrecognized words in network order.
     *
     * @var (string|resource)[]
     */
    protected $unrecognizedWords = array();

    /**
     * The response type.
     *
     * @var string
     */
    private $_type;

    /**
     * Extracts a new response from a communicator.
     *
     * @param Communicator  $com       The communicator from which to extract
     *     the new response.
     * @param int|null      $streamOn  Threshold after which to stream
     *     a word. NULL to disable streaming altogether.
     * @param int           $sTimeout  If a response is not immediately
     *     available, wait this many seconds. If NULL, wait indefinitely.
     * @param int|null      $usTimeout Microseconds to add to the waiting time.
     * @param Registry|null $reg       An optional registry to sync the
     *     response with.
     *
     * @see getType()
     * @see getArgument()
     */
    public function __construct(
        Communicator $com,
        $streamOn = null,
        $sTimeout = 0,
        $usTimeout = null,
        Registry $reg = null
    ) {
        if (null === $reg) {
            if ($com->getTransmitter()->isPersistent()) {
                $old = $com->getTransmitter()
                    ->lock(T\Stream::DIRECTION_RECEIVE);
                try {
                    $this->_receive($com, $streamOn, $sTimeout, $usTimeout);
                } catch (E $e) {
                    $com->getTransmitter()->lock($old, true);
                    throw $e;
                }
                $com->getTransmitter()->lock($old, true);
            } else {
                $this->_receive($com, $streamOn, $sTimeout, $usTimeout);
            }
        } else {
            while (null === ($response = $reg->getNextResponse())) {
                $newResponse = new self($com, 0, $sTimeout, $usTimeout);
                $tagInfo = $reg::parseTag($newResponse->getTag());
                $newResponse->setTag($tagInfo[1]);
                if (!$reg->add($newResponse, $tagInfo[0])) {
                    $response = $newResponse;
                    break;
                }
            }

            $this->_type = $response->_type;
            $this->setTag($response->getTag());
            $this->attributes = $response->attributes;
            $this->unrecognizedWords = $response->unrecognizedWords;
            if (null === $streamOn) {
                foreach ($response->attributes as $name => $value) {
                    $this->setAttribute(
                        $name,
                        stream_get_contents($value)
                        stream_get_contents(/** @scrutinizer ignore-type */ $value)
                    );
                }
                foreach ($response->unrecognizedWords as $i => $value) {
                    $this->unrecognizedWords[$i] = stream_get_contents($value);
                }
            } elseif (0 !== $streamOn) {
                foreach ($response->attributes as $name => $value) {
                    $valueLength = $com::seekableStreamLength($value);
                    $valueLength = $com::seekableStreamLength(/** @scrutinizer ignore-type */ $value);
                    if ((strlen($name) + 2 + $valueLength) < $streamOn) {
                        $this->setAttribute(
                            $name,
                            stream_get_contents($value)
                        );
                    }
                }
                foreach ($response->unrecognizedWords as $i => $value) {
                    $valueLength = $com::seekableStreamLength($value);
                    if ($valueLength < $streamOn) {
                        $this->unrecognizedWords[$i] = stream_get_contents(
                            $value
                        );
                    }
                }
            }
        }
    }

    /**
     * Extracts a new response from a communicator.
     *
     * This is the function that performs the actual receiving, while the
     * constructor is also involved in locks and registry sync.
     *
     * @param Communicator $com       The communicator from which to extract
     *     the new response.
     * @param int|null     $streamOn  Threshold after which to stream
     *     a word. NULL to disable streaming altogether.
     * @param int          $sTimeout  If a response is not immediately
     *     available, wait this many seconds. If NULL, wait indefinitely.
     *     Note that if an empty sentence is received, the timeout will be
     *     reset for another sentence receiving.
     * @param int|null     $usTimeout Microseconds to add to the waiting time.
     *
     * @return void
     */
    private function _receive(
        Communicator $com,
        $streamOn = null,
        $sTimeout = 0,
        $usTimeout = null
    ) {
        do {
            if (!$com->getTransmitter()->isDataAwaiting(
                $sTimeout,
                $usTimeout
            )
            ) {
                throw new SocketException(
                    'No data within the time limit',
                    SocketException::CODE_NO_DATA
                );
            }
            $type = $com->getNextWord();
        } while ('' === $type);
        $this->setType($type);
        if (null === $streamOn) {
            for ($word = $com->getNextWord(); '' !== $word; $word = $com->
                getNextWord()) {
                if (preg_match('/^=([^=]+)=(.*)$/sS', $word, $matches)) {
                    $this->setAttribute($matches[1], $matches[2]);
                } elseif (preg_match('/^\.tag=(.*)$/sS', $word, $matches)) {
                    $this->setTag($matches[1]);
                } else {
                    $this->unrecognizedWords[] = $word;
                }
            }
        } else {
            while ($com->getNextWordLength() !== 0) {
                if ($com->getNextWordLength() < $streamOn) {
                    $word = $com->getNextWord();
                    if (preg_match('/^=([^=]+)=(.*)$/sS', $word, $matches)) {
                        $this->setAttribute($matches[1], $matches[2]);
                    } elseif (preg_match('/^\.tag=(.*)$/sS', $word, $matches)) {
                        $this->setTag($matches[1]);
                    } else {
                        $this->unrecognizedWords[] = $word;
                    }
                } else {
                    $word = $com->getNextWordAsStream();
                    $ind = fread($word, 1);
                    if ('=' === $ind || '.' === $ind) {
                        $prefix = stream_get_line($word, 0, '=');
                    }
                    if ('=' === $ind) {
                        $value = fopen('php://temp', 'r+b');
                        $bytesCopied = ftell($word);
                        while (!feof($word)) {
                            $bytesCopied += stream_copy_to_stream(
                                $word,
                                $value,
                                0xFFFFF,
                                $bytesCopied
                            );
                        }
                        rewind($value);
                        $this->setAttribute($prefix, $value);

                        continue;
                    }
                    if ('.' === $ind && 'tag' === $prefix) {
                        $this->setTag(stream_get_contents($word, -1, -1));
                        continue;
                    }
                    rewind($word);
                    $this->unrecognizedWords[] = $word;
                }
            }
            $com->getNextWord();
        }
    }

    /**
     * Sets the response type.
     *
     * Sets the response type. Valid values are the TYPE_* constants.
     *
     * @param string $type The new response type.
     *
     * @return $this The response object.
     *
     * @see getType()
     */
    protected function setType($type)
    {
        switch ($type) {
        case self::TYPE_FINAL:
        case self::TYPE_DATA:
        case self::TYPE_EMPTY:
        case self::TYPE_ERROR:
        case self::TYPE_FATAL:
            $this->_type = $type;
            return $this;
        default:
            throw new UnexpectedValueException(
                'Unrecognized response type.',
                UnexpectedValueException::CODE_RESPONSE_TYPE_UNKNOWN,
                null,
                $type
            );
        }
    }

    /**
     * Gets the response type.
     *
     * @return string The response type.
     *
     * @see setType()
     */
    public function getType()
    {
        return $this->_type;
    }

    /**
     * Gets the value of an argument.
     *
     * @param string $name The name of the argument.
     *
     * @return string|resource|null The value of the specified argument.
     *     Returns NULL if such an argument is not set.
     *
     * @deprecated         1.0.0b5 Use {@link static::getProperty()} instead.
     *     This method will be removed upon final release, and is currently
     *     left standing merely because it can't be easily search&replaced in
     *     existing code, due to the fact the name "getArgument()" is shared
     *     with {@link Request::getArgument()}, which is still valid.
     * @codeCoverageIgnore
     */
    public function getArgument($name)
    {
        trigger_error(
            'Response::getArgument() is deprecated in favor of ' .
            'Response::getProperty() (but note that Request::getArgument() ' .
            'is still valid)',
            E_USER_DEPRECATED
        );
        return $this->getAttribute($name);
    }

    /**
     * Gets the value of a property.
     *
     * @param string $name The name of the property.
     *
     * @return string|resource|null The value of the specified property.
     *     Returns NULL if such a property is not set.
     */
    public function getProperty($name)
    {
        return $this->getAttribute($name);
    }

    /**
     * Gets a list of unrecognized words.
     *
     * @return string[] The list of unrecognized words.
     */
    public function getUnrecognizedWords()
    {
        return $this->unrecognizedWords;
    }

    /**
     * Get actionable debug info.
     *
     * This is a magic method available to PHP 5.6 and above, due to which
     * output of var_dump() will be more actionable.
     *
     * You can still call it in earlier versions to get the object as a
     * plain array.
     *
     * @return array The info, as an associative array.
     */
    public function __debugInfo()
    {
        return parent::__debugInfo() + array(
            'unrecognized' => $this->unrecognizedWords
        );
    }
}

pear2 / Net_RouterOS

Response::__construct() C last analyzed 2025-03-03 12:38 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Response::__construct() C
last analyzed 2025-03-03 12:38 UTC
