Soluble\DbWrapper\Result\Resultset

Complexity

Total Complexity

20

Size/Duplication

Total Lines	201
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

68.08%

Importance

Changes	5
Bugs	1	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	rewind()	0	4	1
A	valid()	0	4	1
A	count()	0	4	1
A	append()	0	9	2
A	offsetExists()	0	4	1
A	offsetGet()	0	4	2
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	getArray()	0	4	1
A	getArrayObject()	0	8	2
A	getReturnType()	0	4	1

<?php

namespace Soluble\DbWrapper\Result;

use ArrayObject;
use Soluble\DbWrapper\Exception;

class Resultset implements ResultInterface
{

    const TYPE_ARRAYOBJECT = 'arrayobject';
    const TYPE_ARRAY  = 'array';

    /**
     * Allowed return types
     *
     * @var array
     */
    protected $allowedReturnTypes = [
        self::TYPE_ARRAYOBJECT,
        self::TYPE_ARRAY,
    ];


    /**
     * Return type to use when returning an object from the set
     *
     * @var ResultSet::TYPE_ARRAYOBJECT|ResultSet::TYPE_ARRAY
     */
    protected $returnType = self::TYPE_ARRAY;


    /**
     *
     * @var integer 
     */
    protected $position = 0;

    /**
     *
     * @var integer
     */
    protected $count = 0;

    /**
     *
     * @var array|ArrayObject
     */
    protected $storage;


    /**
     * Constructor
     *
     * @throws Exception\InvalidArgumentException
     * @param string $returnType
     */
    public function __construct($returnType = self::TYPE_ARRAY)
    {
        if (!in_array($returnType, $this->allowedReturnTypes)) {
            throw new Exception\InvalidArgumentException("Unsupported returnType argument ($returnType)");
        }
        $this->returnType = $returnType;
        if ($this->returnType == self::TYPE_ARRAYOBJECT) {
            $this->storage = new ArrayObject([]);
        }
        $this->position = 0;
        $this->count = count($this->storage);
    }

    /**
     * {@inheritdoc}
     * @return array|ArrayObject
     */
    public function current()
    {
        return $this->storage[$this->position];
    }

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

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        ++$this->position;
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->position=0;
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return isset($this->storage[$this->position]);
    }

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

    /**
     * Append a row to the end of resultset
     * 
     * @param array $row an associative array
     */
    public function append(array $row)
    {
        if ($this->returnType == self::TYPE_ARRAYOBJECT) {
            $this->storage[] = new ArrayObject($row);
        } else {
            $this->storage[] = $row;
        }
        ++$this->count;
    }


    /**
     * 
     * {@inheritdoc}
     */
    public function offsetExists($position)
    {
        return isset($this->storage[$position]);
    }

    /**
     * 
     * {@inheritdoc}
     */
    public function offsetGet($position)
    {
        return isset($this->storage[$position]) ? $this->storage[$position] : null;
    }

    /**
     * 
     * {@inheritdoc}
     */
    public function offsetSet($position, $row)
    {
        throw new \Exception('Resultsets are immutable');
    }

    /**
     * 
     * {@inheritdoc}
     */
    public function offsetUnset($position)
    {
        throw new \Exception("Resultsets are immutable");
    }

    /**
     * Return underlying stored resultset as array
     * @return array
     */
    public function getArray()
    {
        return (array) $this->storage;
    }

    /**
     * Return underlying stored resultset as ArrayObject
     * 
     * Depending on the $returnType Resultset::TYPE_ARRAY|Resultset::TYPE_ARRAYOBJECT you can modify
     * the internal storage
     * 
     * @return ArrayObject
     */
    public function getArrayObject()
    {
        if ($this->returnType == self::TYPE_ARRAY) {
            return new ArrayObject($this->storage);
        } else {
            return $this->storage;

The expression $this->storage; of type array|ArrayObject adds the type array to the return on line 195 which is incompatible with the return type documented by Soluble\DbWrapper\Result\Resultset::getArrayObject of type ArrayObject.

        }
    }

    /**
     * Return the currently set return type 
     * @see Resultset::TYPE_ARRAY|Resultset::TYPE_ARRAYOBJECT
     * @return string
     */
    public function getReturnType()
    {
        return $this->returnType;
    }
}