Spiral\ORM\Entities\RecordIterator

Complexity

Total Complexity

25

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	2
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	count()	0	4	1
A	all()	0	17	2
A	current()	0	15	2
A	next()	0	4	1
A	key()	0	4	1
A	valid()	0	4	1
A	rewind()	0	4	1
D	has()	0	37	10
A	__call()	0	8	2
A	jsonSerialize()	0	4	1
A	__debugInfo()	0	4	1
A	__destruct()	0	6	1

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */
namespace Spiral\ORM\Entities;

use Spiral\ORM\Exceptions\IteratorException;
use Spiral\ORM\Exceptions\ORMException;
use Spiral\ORM\ORM;
use Spiral\ORM\RecordEntity;
use Spiral\ORM\RecordInterface;

/**
 * Provides iteration over set of specified records data using internal instances cache. In
 * addition, allows to decorate set of callbacks with association by their name (@see __call()).
 * Keeps record context.
 */
class RecordIterator implements \Iterator, \Countable, \JsonSerializable
{
    /**
     * Current iterator position.
     *
     * @var int
     */
    private $position = 0;

    /**
     * Set of "methods" to be decorated.
     *
     * @var callable[]
     */
    private $callbacks = [];

    /**
     * @var string
     */
    protected $class = '';

    /**
     * Indication that entity cache must be used.
     *
     * @var bool
     */
    protected $cache = true;

    /**
     * Data to be iterated.
     *
     * @var array
     */
    protected $data = [];

    /**
     * Constructed record instances. Cache.
     *
     * @var RecordEntity[]
     */
    protected $instances = [];

    /**
     * @invisible
     * @var ORM
     */
    protected $orm = null;

    /**
     * @param ORM        $orm
     * @param string     $class
     * @param array      $data
     * @param bool       $cache
     * @param callable[] $callbacks
     */
    public function __construct(ORM $orm, $class, array $data, $cache = true, array $callbacks = [])
    {
        $this->class = $class;
        $this->cache = $cache;

        $this->orm = $orm;
        $this->data = $data;

        //Magic functionality provided by outer parent
        $this->callbacks = $callbacks;
    }

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

    /**
     * Get all Records as array.
     *
     * @return RecordInterface[]
     */
    public function all()
    {
        $result = [];

        /**
         * @var self|RecordInterface[] $iterator
         */
        $iterator = clone $this;
        foreach ($iterator as $nested) {
            $result[] = $nested;
        }

        //Copying instances just in case
        $this->instances = $iterator->instances;

        return $result;
    }

    /**
     * {@inheritdoc}
     *
     * @return RecordInterface
     * @see ORM::record()
     * @see Record::setContext()
     * @throws ORMException
     */
    public function current()
    {
        if (isset($this->instances[$this->position])) {
            //Due record was pre-constructed we must update it's context to force values for relations
            //and pivot fields
            return $this->instances[$this->position];
        }

        //Let's ask ORM to create needed record
        return $this->instances[$this->position] = $this->orm->record(
            $this->class,
            $this->data[$this->position],
            $this->cache
        );
    }

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

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

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

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

    /**
     * Check if record or record with specified id presents in iteration.
     *
     * @param RecordEntity|string|int $record
     * @return true
     */
    public function has($record)
    {
        /**
         * @var self|RecordEntity[] $iterator
         */
        $iterator = clone $this;
        foreach ($iterator as $nested) {
            $found = false;
            if (is_array($record)) {
                if (array_intersect_assoc($nested->getFields(), $record) == $record) {
                    //Comparing fields intersection
                    $found = true;
                }
            } elseif (!$record instanceof RecordEntity) {

                if (!empty($record) && $nested->primaryKey() == $record) {
                    //Comparing using primary keys
                    $found = true;
                }
            } elseif ($nested == $record || $nested->getFields() == $record->getFields()) {
                //Comparing as class
                $found = true;
            }

            if ($found) {
                //They all must be iterated already
                $this->instances = $iterator->instances;

                return true;
            }
        }

        //They all must be iterated already
        $this->instances = $iterator->instances;

        return false;
    }

    /**
     * Executes decorated method providing itself as function argument.
     *
     * @param string $method
     * @param array  $arguments
     * @return mixed
     * @throws IteratorException
     */
    public function __call($method, array $arguments)
    {
        if (!isset($this->callbacks[$method])) {
            throw new IteratorException("Undefined method or callback.");
        }

        return call_user_func($this->callbacks[$method], $this);
    }

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

    /**
     * @return RecordEntity[]
     */
    public function __debugInfo()
    {
        return $this->all();
    }

    /**
     * Flushing references.
     */
    public function __destruct()
    {
        $this->data = [];
        $this->instances = [];
        $this->orm = null;
    }
}