ResponseIterator::valid() - Code Metrics - Inspection of "Refactoring" - EvilFreelancer/routeros-api-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#33)

by Mr

created 2020-04-17 20:12 UTC

ResponseIterator::valid() A

↳ Parent: ResponseIterator

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace RouterOS;

use \Iterator,
    \ArrayAccess,
    \Countable,
    \Serializable;

/**
 * This class was created by memory save reasons, it convert response
 * from RouterOS to readable array in safe way.
 *
 * @param array $raw Array RAW response from server
 *
 * @return mixed
 *
 * Based on RouterOSResponseArray solution by @arily
 *
 * @package RouterOS\Iterators
 * @link    https://github.com/arily/RouterOSResponseArray
 * @since   1.0.0
 */
class ResponseIterator implements Iterator, ArrayAccess, Countable, Serializable
{
    /**
     * List of parser results from array
     *
     * @var array
     */
    private $parsed = [];

    /**
     * List of RAW results from RouterOS
     *
     * @var array
     */
    private $raw = [];

    /**
     * Initial value of array position
     *
     * @var int
     */
    private $current = 0;

    /**
     * Object of main client
     *
     * @var \RouterOS\Client
     */
    private $client;

    /**
     * ResponseIterator constructor.
     *
     * @param Client $client
     */
    public function __construct(Client $client)
    {
        // Set current to default
        $this->rewind();

        // Save client as parameter of object
        $this->client = $client;

        // Read RAW data from client
        $raw = $client->read(false);

        // This RAW should't be an error
        $positions = array_keys($raw, '!re');
        $count     = count($raw);
        $result    = [];

        if (isset($positions[1])) {

            foreach ($positions as $key => $position) {

                // Get length of future block
                $length = isset($positions[$key + 1])
                    ? $positions[$key + 1] - $position + 1
                    : $count - $position;

                // Convert array to simple items, save as result
                $result[] = array_slice($raw, $position, $length);
            }

        } else {
            $result = [$raw];
        }

        $this->raw = $result;
    }

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

    /**
     * Previous value
     */
    public function prev()
    {
        --$this->current;
    }

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

        if ($this->valid()) {

            if (!isset($this->parsed[$this->current])) {
                $value = $this->client->parseResponse($this->raw[$this->current])[0];
                $this->offsetSet($this->current, $value);
            }

            return $this->parsed[$this->current];
        }

        return null;
    }

    /**
     * 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;
        } else {
            $this->parsed[$offset] = $value;
        }
    }

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

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

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

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

        return false;
    }

    /**
     * String representation of object
     *
     * @return string
     */
    public function serialize(): string
    {
        return serialize($this->raw);
    }

    /**
     * Constructs the object
     *
     * @param string $serialized
     */
    public function unserialize($serialized)
    {
        $this->raw = unserialize($serialized, null);
    }
}


1		<?php
2
3		namespace RouterOS;
4
5		use \Iterator,
6		\ArrayAccess,
7		\Countable,
8		\Serializable;
9
10		/**
11		* This class was created by memory save reasons, it convert response
12		* from RouterOS to readable array in safe way.
13		*
14		* @param array $raw Array RAW response from server
15		*
16		* @return mixed
17		*
18		* Based on RouterOSResponseArray solution by @arily
19		*
20		* @package RouterOS\Iterators
21		* @link https://github.com/arily/RouterOSResponseArray
22		* @since 1.0.0
23		*/
24		class ResponseIterator implements Iterator, ArrayAccess, Countable, Serializable
25		{
26		/**
27		* List of parser results from array
28		*
29		* @var array
30		*/
31		private $parsed = [];
32
33		/**
34		* List of RAW results from RouterOS
35		*
36		* @var array
37		*/
38		private $raw = [];
39
40		/**
41		* Initial value of array position
42		*
43		* @var int
44		*/
45		private $current = 0;
46
47		/**
48		* Object of main client
49		*
50		* @var \RouterOS\Client
51		*/
52		private $client;
53
54		/**
55		* ResponseIterator constructor.
56		*
57		* @param Client $client
58		*/
59	4	public function __construct(Client $client)
60		{
61		// Set current to default
62	4	$this->rewind();
63
64		// Save client as parameter of object
65	4	$this->client = $client;
66
67		// Read RAW data from client
68	4	$raw = $client->read(false);
69
70		// This RAW should't be an error
71	4	$positions = array_keys($raw, '!re');
72	4	$count = count($raw);
73	4	$result = [];
74
75	4	if (isset($positions[1])) {
76
77	3	foreach ($positions as $key => $position) {
78
79		// Get length of future block
80	3	$length = isset($positions[$key + 1])
81	3	? $positions[$key + 1] - $position + 1
82	3	: $count - $position;
83
84		// Convert array to simple items, save as result
85	3	$result[] = array_slice($raw, $position, $length);
86		}
87
88		} else {
89	2	$result = [$raw];
90		}
91
92	4	$this->raw = $result;
93	4	}
94
95		/**
96		* Move forward to next element
97		*/
98		public function next()
99		{
100		++$this->current;
101		}
102
103		/**
104		* Previous value
105		*/
106		public function prev()
107		{
108		--$this->current;
109		}
110
111		/**
112		* Return the current element
113		*
114		* @return mixed
115		*/
116		public function current()
117		{
118		if (isset($this->parsed[$this->current])) {
119		return $this->parsed[$this->current];
120		}
121
122		if ($this->valid()) {
123
124		if (!isset($this->parsed[$this->current])) {
125		$value = $this->client->parseResponse($this->raw[$this->current])[0];
126		$this->offsetSet($this->current, $value);
127		}
128
129		return $this->parsed[$this->current];
130		}
131
132		return null;
133		}
134
135		/**
136		* Return the key of the current element
137		*
138		* @return mixed
139		*/
140		public function key()
141		{
142		return $this->current;
143		}
144
145		/**
146		* Checks if current position is valid
147		*
148		* @return bool
149		*/
150		public function valid(): bool
151		{
152		return isset($this->raw[$this->current]);
153		}
154
155		/**
156		* Count elements of an object
157		*
158		* @return int
159		*/
160	1	public function count(): int
161		{
162	1	return count($this->raw);
163		}
164
165		/**
166		* Rewind the Iterator to the first element
167		*/
168	4	public function rewind()
169		{
170	4	$this->current = 0;
171	4	}
172
173		/**
174		* Offset to set
175		*
176		* @param mixed $offset
177		* @param mixed $value
178		*/
179		public function offsetSet($offset, $value)
180		{
181		if (null === $offset) {
182		$this->parsed[] = $value;
183		} else {
184		$this->parsed[$offset] = $value;
185		}
186		}
187
188		/**
189		* Whether a offset exists
190		*
191		* @param mixed $offset
192		*
193		* @return bool
194		*/
195		public function offsetExists($offset): bool
196		{
197		return isset($this->raw[$offset]) && $this->raw[$offset] !== ['!re'];
198		}
199
200		/**
201		* Offset to unset
202		*
203		* @param mixed $offset
204		*/
205		public function offsetUnset($offset)
206		{
207		unset($this->parsed[$offset], $this->raw[$offset]);
208		}
209
210		/**
211		* Offset to retrieve
212		*
213		* @param mixed $offset
214		*
215		* @return bool\|mixed
216		*/
217	1	public function offsetGet($offset)
218		{
219	1	if (isset($this->parsed[$offset])) {
220		return $this->parsed[$offset];
221		}
222
223	1	if (isset($this->raw[$offset]) && $this->raw[$offset] !== null) {
224	1	$f = $this->client->parseResponse($this->raw[$offset]);
225		if ($f !== []) {
226		return $this->parsed[$offset] = $f[0];
227		}
228		}
229
230		return false;
231		}
232
233		/**
234		* String representation of object
235		*
236		* @return string
237		*/
238	1	public function serialize(): string
239		{
240	1	return serialize($this->raw);
241		}
242
243		/**
244		* Constructs the object
245		*
246		* @param string $serialized
247		*/
248		public function unserialize($serialized)
249		{
250		$this->raw = unserialize($serialized, null);
251		}
252		}
253

EvilFreelancer / routeros-api-php

Pull Request — master (#33)

ResponseIterator::valid() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like