Cubiche\Core\Collections\DataSource\IteratorDataSource

Complexity

Total Complexity

25

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
B	getIterator()	0	20	5
A	findOne()	0	8	2
A	filteredDataSource()	0	14	3
A	slicedDataSource()	0	10	2
A	sortedDataSource()	0	10	1
A	calculateCount()	0	4	1
A	evaluate()	0	4	2
A	checkOffset()	0	4	2
A	checkLenght()	0	4	2
A	sort()	0	13	4

<?php

/**
 * This file is part of the Cubiche package.
 *
 * Copyright (c) Cubiche
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Cubiche\Core\Collections\DataSource;

use Cubiche\Core\Comparable\ComparatorInterface;
use Cubiche\Core\Specification\SpecificationInterface;

/**
 * Iterator Data Source Class.
 *
 * @author Karel Osorio Ramírez <osorioramirez@gmail.com>
 */
class IteratorDataSource extends DataSource
{
    /**
     * @var \Traversable
     */
    protected $iterator;

    /**
     * @var bool
     */
    private $iteratorSorted;

    /**
     * @param \Traversable           $iterator
     * @param SpecificationInterface $searchCriteria
     * @param ComparatorInterface    $sortCriteria
     * @param int                    $offset
     * @param int                    $length
     */
    public function __construct(
        \Traversable $iterator,
        SpecificationInterface $searchCriteria = null,
        ComparatorInterface $sortCriteria = null,
        $offset = null,
        $length = null
    ) {
        parent::__construct($searchCriteria, $sortCriteria, $offset, $length);

        $this->iterator = $iterator;
        $this->iteratorSorted = false;
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        $this->sort();

        $count = 0;
        $offset = 0;
        foreach ($this->iterator as $item) {
            if (!$this->checkLenght($count)) {
                break;
            }
            if ($this->evaluate($item) === true) {
                if ($this->checkOffset($offset)) {
                    ++$count;
                    yield $item;
                } else {
                    ++$offset;
                }
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function findOne()
    {
        foreach ($this->getIterator() as $item) {
            return $item;
        }

        return;
    }

    /**
     * {@inheritdoc}
     */
    public function filteredDataSource(SpecificationInterface $criteria)
    {
        if ($this->isFiltered()) {
            $criteria = $this->searchCriteria()->andX($criteria);
        }

        return new self(
            $this->iterator,
            $criteria,
            $this->iteratorSorted ? null : $this->sortCriteria(),
            $this->offset(),
            $this->length()
        );
    }

    /**
     * {@inheritdoc}
     */
    public function slicedDataSource($offset, $length = null)
    {
        return new self(
            $this->iterator,
            $this->searchCriteria(),
            $this->iteratorSorted ? null : $this->sortCriteria(),
            $this->actualOffset($offset),
            $this->actualLength($offset, $length)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function sortedDataSource(ComparatorInterface $sortCriteria)
    {
        return new self(
            $this->iterator,
            $this->searchCriteria(),
            $sortCriteria,
            $this->offset(),
            $this->length()
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function calculateCount()
    {
        return \iterator_count($this->getIterator());
    }

    /**
     * @param mixed $item
     *
     * @return bool
     */
    protected function evaluate($item)
    {
        return $this->searchCriteria() === null || $this->searchCriteria()->evaluate($item);
    }

    /**
     * @param int $offset
     *
     * @return bool
     */
    private function checkOffset($offset)
    {
        return $this->offset === null || $offset === $this->offset;
    }

    /**
     * @param int $count
     *
     * @return bool
     */
    private function checkLenght($count)
    {
        return $this->length === null || $count < $this->length;
    }

    private function sort()
    {
        if (!$this->iteratorSorted && $this->isSorted()) {
            if (!($this->iterator instanceof \ArrayIterator)) {
                $this->iterator = new \ArrayIterator(iterator_to_array($this->iterator));
            }
            $this->iterator->uasort(function ($a, $b) {
                return $this->sortCriteria()->compare($a, $b);
            });

            $this->iteratorSorted = true;
        }
    }
}