Soluble\FlexStore\ResultSet\ResultSet

Complexity

Total Complexity

35

Size/Duplication

Total Lines	282
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

94.34%

Importance

Changes	3
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getColumnModel()	0	8	2
A	setSource()	0	5	1
A	getSource()	0	4	1
A	setHydrationOptions()	0	5	1
A	getPaginator()	0	11	2
A	setTotalRows()	0	5	1
A	getTotalRows()	0	4	1
A	getHydrationOptions()	0	4	1
C	initColumnModelHydration()	0	39	7
D	current()	0	38	10
B	toArray()	0	18	5
A	valid()	0	8	2
A	rewind()	0	5	1

<?php

namespace Soluble\FlexStore\ResultSet;

use Soluble\FlexStore\Source\AbstractSource;
use Soluble\FlexStore\Helper\Paginator;
use Soluble\FlexStore\Options\HydrationOptions;
use Soluble\FlexStore\Column\ColumnModel;
use ArrayObject;

class ResultSet extends AbstractResultSet
{
    /**
     *
     * @var Paginator
     */
    protected $paginator;

    /**
     *
     * @var integer
     */
    protected $totalRows;

    /**
     * @var AbstractSource
     */
    protected $source;

    /**
     *
     * @var HydrationOptions
     */
    protected $hydrationOptions;

    /**
     *
     * @var boolean
     */
    protected $hydrate_options_initialized = false;

    /**
     * @var ArrayObject
     */
    protected $hydration_formatters;

    /**
     * @var ArrayObject
     */
    protected $hydration_renderers;

    /**
     * @var ArrayObject|null
     */
    protected $hydrated_columns;



    /**
     * Return source column model
     *
     * @throws Exception\RuntimeException
     * @return ColumnModel
     */
    public function getColumnModel()
    {
        if ($this->source === null) {
            throw new Exception\RuntimeException(__METHOD__ . " Prior to get column model, a source must be set.");
        }
        $this->hydrate_options_initialized = false;
        return $this->source->getColumnModel();
    }

    /**
     *
     * @param AbstractSource $source
     * @return ResultSet
     */
    public function setSource(AbstractSource $source)
    {
        $this->source = $source;
        return $this;
    }

    /**
     *
     * @return AbstractSource
     */
    public function getSource()
    {
        return $this->source;
    }

    /**
     *
     * @param HydrationOptions $hydrationOptions
     * @return ResultSet
     */
    public function setHydrationOptions(HydrationOptions $hydrationOptions)
    {
        $this->hydrationOptions = $hydrationOptions;
        return $this;
    }

    /**
     *
     * @return HydrationOptions
     */
    public function getHydrationOptions()
    {
        return $this->hydrationOptions;
    }


    /**
     *
     * @return Paginator
     */
    public function getPaginator()
    {
        if ($this->paginator === null) {
            $this->paginator = new Paginator(
                $this->getTotalRows(),
                $this->getSource()->getOptions()->getLimit(),
                $this->getSource()->getOptions()->getOffset()
            );
        }
        return $this->paginator;
    }

    /**
     * Set the total rows
     * @param int $totalRows
     * @return ResultSet
     */
    public function setTotalRows($totalRows)
    {
        $this->totalRows = (int) $totalRows;
        return $this;
    }

    /**
     * @return int
     */
    public function getTotalRows()
    {
        return $this->totalRows;
    }

    /**
     *
     * @param ArrayObject|array $row
     * @return null
     */
//protected function initColumnModelHydration(ArrayObject $row)    
    protected function initColumnModelHydration(&$row)
    {
        $this->hydration_formatters = new ArrayObject();
        $this->hydration_renderers = new ArrayObject();
        $this->hydrated_columns = null;

        if ($this->source->hasColumnModel()) {
            $cm = $this->getColumnModel();

            // 1. Initialize columns hydrators
            if ($this->getHydrationOptions()->isFormattersEnabled()) {
                $formatters = $cm->getUniqueFormatters();
                if ($formatters->count() > 0) {
                    $this->hydration_formatters = $formatters;
                }
            }

            // 2. Initialize hydrated columns

            if ($this->getHydrationOptions()->isColumnExclusionEnabled()) {
                $columns = $cm->getColumns();

                // Performance:
                // Only if column model definition differs from originating
                // source row definition.
                $hydrated_columns = array_keys((array) $columns);
                $row_columns = array_keys((array) $row);
                if ($hydrated_columns != $row_columns) {
                    $this->hydrated_columns = new ArrayObject($hydrated_columns);
                }
            }

            // 3. Initialize row renderers
            if ($this->getHydrationOptions()->isRenderersEnabled()) {
                $this->hydration_renderers = $cm->getRowRenderers();
            }
        }
        $this->hydrate_options_initialized = true;
    }

    /**
     * Return the current row as an array|ArrayObject.
     * If setLimitColumns() have been set, will only return
     * the limited columns.
     *
     * @throws Exception\UnknownColumnException
     * @return array|ArrayObject|null
     */
    public function current()
    {
        $row = $this->zfResultSet->current();
        if ($row === null) {
            return;
        }

        if (!$this->hydrate_options_initialized) {
            $this->initColumnModelHydration($row);
        }


        // 1. Row renderers
        foreach ($this->hydration_renderers as $renderer) {
            $renderer->apply($row);
        }

        // 2. Formatters
        foreach ($this->hydration_formatters as $formatters) {
            foreach ($formatters['columns'] as $column) {
                $row[$column] = $formatters['formatter']->format($row[$column], $row);
            }
        }

        // 3. Process column hydration
        if ($this->hydrated_columns !== null) {
            $d = new ArrayObject();
            foreach ($this->hydrated_columns as $column) {
                $d->offsetSet($column, isset($row[$column]) ? $row[$column] : null);
            }
            $row->exchangeArray($d);
        }

        if ($this->returnType === self::TYPE_ARRAY) {
            return (array) $row;
        }
        return $row;
    }

    /**
     * Cast result set to array of arrays
     *
     * @return array
     * @throws Exception\RuntimeException if any row is not castable to an array
     */
    public function toArray()
    {
        $return = [];
        foreach ($this as $row) {
            if (is_array($row)) {
                $return[] = $row;
            } elseif (method_exists($row, 'toArray')) {
                $return[] = $row->toArray();

It seems like you code against a specific sub-type and not the parent class ArrayObject as the method toArray() does only exist in the following sub-classes of ArrayObject: Zend\Stdlib\Parameters. Maybe you want to instanceof check for one of these explicitly?

            } elseif (method_exists($row, 'getArrayCopy')) {
                $return[] = $row->getArrayCopy();
            } else {
                throw new Exception\RuntimeException(
                    __METHOD__ . ': Rows as part of this DataSource, with type ' . gettype($row) . ' cannot be cast to an array'
                );
            }
        }
        return $return;
    }

    /**
     * Iterator: is pointer valid?
     *
     * @return bool
     */
    public function valid()
    {
        $valid =  $this->zfResultSet->valid();
        if (!$valid) {
            $this->hydrate_options_initialized = false;
        }
        return $valid;
    }

    /**
     * Iterator: rewind
     *
     * @return void
     */
    public function rewind()
    {
        $this->hydrate_options_initialized = false;
        $this->zfResultSet->rewind();
    }
}