chillerlan\Database\DBResult

Complexity

Total Complexity

23

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	20	6
A	__merge()	0	11	2
A	__toArray()	0	9	2
A	chunk()	0	3	1
A	magic_get_length()	0	3	1
A	offsetExists()	0	3	1
A	offsetGet()	0	3	1
A	offsetSet()	0	10	2
A	offsetUnset()	0	3	1
A	count()	0	3	1
A	current()	0	3	1
A	key()	0	3	1
A	valid()	0	3	1
A	next()	0	3	1
A	rewind()	0	3	1

<?php
/**
 * Class DBResult
 *
 * @filesource   DBResult.php
 * @created      23.05.2017
 * @package      chillerlan\Database
 * @author       Smiley <smiley@chillerlan.net>
 * @copyright    2017 Smiley
 * @license      MIT
 */

namespace chillerlan\Database;

use ArrayAccess, Countable, Iterator;
use chillerlan\Database\Traits\{Enumerable, Magic};

/**
 * @property int $length
 *
 * each($func [, $fieldname)
 */
class DBResult implements Iterator, ArrayAccess, Countable{
	use Enumerable, Magic;

	/**
	 * @var \chillerlan\Database\DBResultRow[]
	 */
	protected $array = [];

	/**
	 * @var int
	 */
	protected $offset = 0;
	protected $sourceEncoding;
	protected $destEncoding;

	/**
	 * DBResult constructor.
	 *
	 * @param \Traversable|\stdClass|array|null $data
	 * @param string|null                       $sourceEncoding
	 * @param string                            $destEncoding
	 *
	 * @throws \chillerlan\Database\DBException
	 */
	public function __construct($data = null, $sourceEncoding = null, $destEncoding = 'UTF-8'){
		$this->sourceEncoding = $sourceEncoding;
		$this->destEncoding   = $destEncoding;

		if(is_null($data)){
			$data = [];
		}
		else if($data instanceof \Traversable){
			$data = iterator_to_array($data);
		}
		else if(!$data instanceof \stdClass && !is_array($data)){
			throw new DBException('invalid data');
		}

		foreach($data as $k => $v){

The expression $data of type object<stdClass>|array is not guaranteed to be traversable. How about adding an additional type check?

			$this->offsetSet($k, $v);
		}

		$this->offset = 0;
	}

	/**
	 * @param \chillerlan\Database\DBResult $DBResult
	 *
	 * @return \chillerlan\Database\DBResult
	 */
	public function __merge(DBResult $DBResult){
		$arr = [];

		foreach($DBResult as $row){
			$arr[] = $row;
		}

		$this->array = array_merge($this->array, $arr);

It seems like array_merge($this->array, $arr) of type array is incompatible with the declared type array<integer,object<chillerlan\Database\DBResultRow>> of property $array.

		return $this;
	}

	/**
	 * @link http://api.prototypejs.org/language/Enumerable/prototype/toArray/
	 *
	 * @return array
	 */
	public function __toArray():array {
		$arr = [];

		foreach($this->array as $item){
			$arr[] = $item->__toArray();
		}

		return $arr;
	}

	public function chunk(int $size){
		return array_chunk($this->__toArray(), $size);
	}

	/*********
	 * magic *
	 *********/

	/**
	 * @return int
	 */
	protected function magic_get_length():int{
		return $this->count();
	}


	/***************
	 * ArrayAccess *
	 ***************/

	/**
	 * @param int|string $offset
	 *
	 * @return bool
	 */
	public function offsetExists($offset):bool{
		return isset($this->array[$offset]);
	}

	/**
	 * @param int|string $offset
	 *
	 * @return \chillerlan\Database\DBResultRow|mixed|null

Consider making the return type a bit more specific; maybe use DBResultRow|null.

	 */
	public function offsetGet($offset){
		return $this->array[$offset] ?? null;
	}

	/**
	 * @param int|string   $offset
	 * @param array        $value
	 *
	 * @return void
	 */
	public function offsetSet($offset, $value){

		if(is_null($offset)){
			$this->array[] = new DBResultRow($value, $this->sourceEncoding, $this->destEncoding);
		}
		else{
			$this->array[$offset] = new DBResultRow($value, $this->sourceEncoding, $this->destEncoding);
		}

	}

	/**
	 * @param int|string $offset
	 *
	 * @return void
	 */
	public function offsetUnset($offset){
		unset($this->array[$offset]);
	}


	/*************
	 * Countable *
	 *************/

	/**
	 * @return int
	 */
	public function count():int{
		return count($this->array);
	}


	/************
	 * Iterator *
	 ************/

	/**
	 * @return \chillerlan\Database\DBResultRow|mixed

Consider making the return type a bit more specific; maybe use DBResultRow|null.

	 */
	public function current(){
		return $this->offsetGet($this->offset);
	}

	/**
	 * @return int
	 */
	public function key():int{
		return $this->offset;
	}

	/**
	 * @return bool
	 */
	public function valid():bool{
		return $this->offsetExists($this->offset);
	}

	/**
	 *  @return void
	 */
	public function next(){
		$this->offset++;
	}

	/**
	 * @return void
	 */
	public function rewind(){
		$this->offset = 0;
	}

}