RouterOS\Iterators\ResponseIterator

Complexity

Total Complexity

34

Size/Duplication

Total Lines	130
Duplicated Lines	27.69 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	27	4
A	next()	0	3	1
A	current()	0	9	3
A	key()	0	3	1
A	valid()	0	3	1
A	count()	0	3	1
A	rewind()	0	3	1
A	offsetSet()	0	8	2
A	offsetExists()	0	3	2
A	offsetUnset()	0	4	1
A	offsetGet()	0	13	5
A	flush()	0	4	1
B	parseResponse()	36	36	10
A	pregResponse()	0	3	1

<?php
/**
 * Created by PhpStorm.
 * User: kousakananako
 * Date: 2019/05/30
 * Time: 2:07
 */

namespace RouterOS\Iterators;

/**
 * Class ResponseIterator
 * @package RouterOS\Iterators
 */

class ResponseIterator implements \Iterator, \ArrayAccess, \Countable {

	public $parsed = [];
	public $raw = [];
	public $current;
	public $length;

	public function __construct($raw) {
		$this->current = 0;
		// This RAW should't be an error
		$positions = array_keys($raw, '!re');
		$this->length = count($positions);
		$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;
	}
	public function next() {
		++$this->current;
	}
	public function current() {
		if (isset($this->parsed[$this->current])) {
			return $this->parsed[$this->current];
		} elseif (isset($this->raw[$this->current])) {
			return $this->parseResponse($this->raw[$this->current])[0];
		} else {
			return FALSE;
		}
	}
	public function key() {
		return $this->current;
	}
	public function valid() {
		return isset($this->raw[$this->current]);
	}
	public function count() {
		return count($this->raw);
	}
	public function rewind() {
		$this->current = 0;
	}
	public function offsetSet($offset, $value) {
		if (is_null($offset)) {
			$this->parsed[] = $value;
			throw new \RuntimeException('don\'t append to me It will cause a Bug sometime I PROMISE');
		} else {
			$this->parsed[$offset] = $value;
		}
	}
	public function offsetExists($offset) {
		return isset($this->raw[$offset]) && $this->raw[$offset] !== ['!re'];
	}
	public function offsetUnset($offset) {
		unset($this->parsed[$offset]);
		unset($this->raw[$offset]);
	}
	public function offsetGet($offset) {
		if (isset($this->parsed[$offset])) {
			return $this->parsed[$offset];
		} elseif (isset($this->raw[$offset]) && $this->raw[$offset] !== NULL) {
			$f = $this->parseResponse($this->raw[$offset]);
			if ($f !== []) {
				$r = $this->parsed[$offset] = $f[0];
				return $r;
			}
		} else {
			return FALSE;
		}
	}
	public function flush() {
		$this->raw = [];
		$this->parsed = [];
	}
	private function parseResponse(array $response): array

This method seems to be duplicated in your project.

	{
		$result = [];
		$i = -1;
		$lines = \count($response);
		foreach ($response as $key => $value) {
			switch ($value) {
			case '!re':
				$i++;
				break;
			case '!fatal':
				$result = $response;
				break 2;
			case '!trap':
			case '!done':
				// Check for =ret=, .tag and any other following messages
				for ($j = $key + 1; $j <= $lines; $j++) {
					// If we have lines after current one
					if (isset($response[$j])) {
						$this->pregResponse($response[$j], $matches);
						if (isset($matches[1][0], $matches[2][0])) {
							$result['after'][$matches[1][0]] = $matches[2][0];
						}
					}
				}
				break 2;
			default:
				$this->pregResponse($value, $matches);
				if (isset($matches[1][0], $matches[2][0])) {
					$result[$i][$matches[1][0]] = $matches[2][0];
				}
				break;
			}
		}
		return $result;
	}
	private function pregResponse(string $value, &$matches) {
		preg_match_all('/^[=|\.](.*)=(.*)/', $value, $matches);
	}
}