Rosario::read() - Code Metrics - Inspection of "note about Rosario added to readme" - EvilFreelancer/routeros-api-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 62c183...87995b )

by Mr

created 2019-07-20 10:03 UTC

Rosario::read() A

↳ Parent: Rosario

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	26
ccs	0
cts	11
cp	0
rs	9.504
c	0
b	0
f	0
cc	2
nc	2
nop	1
crap	6

<?php

namespace RouterOS;

use \Iterator,
    \ArrayAccess,
    \Countable;

/**
 * Class Rosario, created for work with response array from RouterOS
 * as with multiple chunks of values, this class was created by memory save reasons.
 *
 * Based on RouterOSResponseArray solution by @arily
 *
 * @link    https://github.com/arily/RouterOSResponseArray
 * @package RouterOS
 * @since   0.10
 */
class Rosario extends Client implements Iterator, ArrayAccess, Countable
{
    /**
     * List of parsed variables
     *
     * @var array
     */
    protected $parsed = [];

    /**
     * List of RAW variables
     *
     * @var array
     */
    protected $raw = [];

    /**
     * Current position of array
     *
     * @var mixed
     */
    protected $current;

    /**
     * Read answer from server after query was executed
     *
     * A Mikrotik reply is formed of blocks
     * Each block starts with a word, one of ('!re', '!trap', '!done', '!fatal')
     * Each block end with an zero byte (empty line)
     * Reply ends with a complete !done or !fatal block (ended with 'empty line')
     * A !fatal block precedes TCP connexion close
     *
     * @param bool $parse
     * @return array
     */
    public function read(bool $parse = true): array
    {
        // Read answer from original client
        $raw = $orig = parent::read($parse);

        // Refresh current position
        $this->current = 0;

        // This RAW should't be an error
        $position = array_keys($raw, '!re');

        // Split RAW to chinks or use as subarray
        if (isset($position[1])) {
            $length = $position[1] - $position[0];
            $raw    = array_chunk($raw, $length);
            array_pop($raw);
        } else {
            $raw = [$raw];
        }

        // Store parsed RAW data
        $this->raw = $raw;

        // Return ready to use array
        return $orig;
    }

    /**
     * Move forward to next element
     */
    public function next()
    {
        ++$this->current;
    }

    /**
     * Return the current element
     *
     * @return mixed
     */
    public function current()
    {
        if (isset($this->parsed[$this->current])) {
            return $this->parsed[$this->current];
        }

        if (isset($this->raw[$this->current])) {
            return $this->parseResponse($this->raw[$this->current])[0];
        }

        return false;
    }

    /**
     * Return the key of the current element
     *
     * @return mixed
     */
    public function key()
    {
        return $this->current;
    }

    /**
     * Checks if current position is valid
     *
     * @return bool
     */
    public function valid(): bool
    {
        return isset($this->raw[$this->current]);
    }

    /**
     * Count elements of an object
     *
     * @return int
     */
    public function count(): int
    {
        return count($this->raw);
    }

    /**
     * Rewind the Iterator to the first element
     */
    public function rewind()
    {
        $this->current = 0;
    }

    /**
     * Offset to set
     *
     * @param mixed $offset
     * @param mixed $value
     */
    public function offsetSet($offset, $value)
    {
        if (null === $offset) {
            $this->parsed[] = $value;
        }
        $this->parsed[$offset] = $value;
    }

    /**
     * Whether a offset exists
     *
     * @param mixed $offset
     * @return bool
     */
    public function offsetExists($offset): bool
    {
        return isset($this->raw[$offset]);
    }

    /**
     * Offset to unset
     *
     * @param mixed $offset
     */
    public function offsetUnset($offset)
    {
        unset($this->parsed[$offset], $this->raw[$offset]);
    }

    /**
     * Offset to retrieve
     *
     * @param mixed $offset
     * @return mixed
     */
    public function offsetGet($offset)
    {
        if (isset($this->parsed[$offset])) {
            return $this->parsed[$offset];
        }

        if (isset($this->raw[$offset])) {
            return $this->parsed[$offset] = $this->parseResponse($this->raw[$offset])[0];
        }

        // For empty() function
        return null;
    }

    /**
     * Cleanup the array
     */
    public function flush()
    {
        $this->raw    = [];
        $this->parsed = [];
    }

}


1			<?php
2
3			namespace RouterOS;
4
5			use \Iterator,
6			\ArrayAccess,
7			\Countable;
8
9			/**
10			* Class Rosario, created for work with response array from RouterOS
11			* as with multiple chunks of values, this class was created by memory save reasons.
12			*
13			* Based on RouterOSResponseArray solution by @arily
14			*
15			* @link https://github.com/arily/RouterOSResponseArray
16			* @package RouterOS
17			* @since 0.10
18			*/
19			class Rosario extends Client implements Iterator, ArrayAccess, Countable
20			{
21			/**
22			* List of parsed variables
23			*
24			* @var array
25			*/
26			protected $parsed = [];
27
28			/**
29			* List of RAW variables
30			*
31			* @var array
32			*/
33			protected $raw = [];
34
35			/**
36			* Current position of array
37			*
38			* @var mixed
39			*/
40			protected $current;
41
42			/**
43			* Read answer from server after query was executed
44			*
45			* A Mikrotik reply is formed of blocks
46			* Each block starts with a word, one of ('!re', '!trap', '!done', '!fatal')
47			* Each block end with an zero byte (empty line)
48			* Reply ends with a complete !done or !fatal block (ended with 'empty line')
49			* A !fatal block precedes TCP connexion close
50			*
51			* @param bool $parse
52			* @return array
53			*/
54			public function read(bool $parse = true): array
55			{
56			// Read answer from original client
57			$raw = $orig = parent::read($parse);
58
59			// Refresh current position
60			$this->current = 0;
61
62			// This RAW should't be an error
63			$position = array_keys($raw, '!re');
64
65			// Split RAW to chinks or use as subarray
66			if (isset($position[1])) {
67			$length = $position[1] - $position[0];
68			$raw = array_chunk($raw, $length);
69			array_pop($raw);
70			} else {
71			$raw = [$raw];
72			}
73
74			// Store parsed RAW data
75			$this->raw = $raw;
76
77			// Return ready to use array
78			return $orig;
79			}
80
81			/**
82			* Move forward to next element
83			*/
84			public function next()
85			{
86			++$this->current;
87			}
88
89			/**
90			* Return the current element
91			*
92			* @return mixed
93			*/
94			public function current()
95			{
96			if (isset($this->parsed[$this->current])) {
97			return $this->parsed[$this->current];
98			}
99
100			if (isset($this->raw[$this->current])) {
101			return $this->parseResponse($this->raw[$this->current])[0];
102			}
103
104			return false;
105			}
106
107			/**
108			* Return the key of the current element
109			*
110			* @return mixed
111			*/
112			public function key()
113			{
114			return $this->current;
115			}
116
117			/**
118			* Checks if current position is valid
119			*
120			* @return bool
121			*/
122			public function valid(): bool
123			{
124			return isset($this->raw[$this->current]);
125			}
126
127			/**
128			* Count elements of an object
129			*
130			* @return int
131			*/
132			public function count(): int
133			{
134			return count($this->raw);
135			}
136
137			/**
138			* Rewind the Iterator to the first element
139			*/
140			public function rewind()
141			{
142			$this->current = 0;
143			}
144
145			/**
146			* Offset to set
147			*
148			* @param mixed $offset
149			* @param mixed $value
150			*/
151			public function offsetSet($offset, $value)
152			{
153			if (null === $offset) {
154			$this->parsed[] = $value;
155			}
156			$this->parsed[$offset] = $value;
157			}
158
159			/**
160			* Whether a offset exists
161			*
162			* @param mixed $offset
163			* @return bool
164			*/
165			public function offsetExists($offset): bool
166			{
167			return isset($this->raw[$offset]);
168			}
169
170			/**
171			* Offset to unset
172			*
173			* @param mixed $offset
174			*/
175			public function offsetUnset($offset)
176			{
177			unset($this->parsed[$offset], $this->raw[$offset]);
178			}
179
180			/**
181			* Offset to retrieve
182			*
183			* @param mixed $offset
184			* @return mixed
185			*/
186			public function offsetGet($offset)
187			{
188			if (isset($this->parsed[$offset])) {
189			return $this->parsed[$offset];
190			}
191
192			if (isset($this->raw[$offset])) {
193			return $this->parsed[$offset] = $this->parseResponse($this->raw[$offset])[0];
194			}
195
196			// For empty() function
197			return null;
198			}
199
200			/**
201			* Cleanup the array
202			*/
203			public function flush()
204			{
205			$this->raw = [];
206			$this->parsed = [];
207			}
208
209			}
210

EvilFreelancer / routeros-api-php

Push — master ( 62c183...87995b )

Rosario::read() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like