Atrapalo\PHPTools\Collection\EntityCollection

Complexity

Total Complexity

26

Size/Duplication

Total Lines	191
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
	entityClass()	0	1	?
A	__construct()	0	12	3
A	add()	0	8	2
A	set()	0	8	2
A	isValid()	0	11	4
A	keys()	0	4	1
A	values()	0	4	1
A	first()	0	4	1
A	last()	0	4	1
A	toArray()	0	4	1
A	slice()	0	9	2
A	current()	0	4	1
A	next()	0	4	1
A	key()	0	4	1
A	valid()	0	4	1
A	rewind()	0	4	1
A	count()	0	4	1
A	customEmptyException()	0	4	1
A	customInvalidEntityException()	0	4	1

<?php

namespace Atrapalo\PHPTools\Collection;

/**
 * Class EntityCollection
 * @package Atrapalo\PHPTools\Collection
 *
 * @author Guillermo González <guillermo.gonzalez@atrapalo.com>
 */
abstract class EntityCollection implements \Countable, \Iterator
{
    /** @var array */
    private $entities = array();
    /** @var bool */
    protected $allowEntitiesChildren;

    /**
     * @return string
     */
    abstract public static function entityClass(): string;

    /**
     * Collection constructor.
     * @param array $entities
     * @param bool  $allowEntitiesChildren
     * @throws \Exception
     */
    public function __construct(array $entities, bool $allowEntitiesChildren = false)
    {
        if (empty($entities)) {
            throw static::customEmptyException();
        }

        $this->allowEntitiesChildren = $allowEntitiesChildren;

        foreach ($entities as $entity) {
            $this->add($entity);
        }
    }

    /**
     * @param $entity
     * @throws \Exception
     */
    public function add($entity)
    {
        if (!$this->isValid($entity)) {
            throw static::customInvalidEntityException();
        }

        $this->entities[] = $entity;
    }

    /**
     * @param $key
     * @param $entity
     * @throws \Exception
     */
    protected function set($key, $entity)
    {
        if (!$this->isValid($entity)) {
            throw static::customInvalidEntityException();
        }

        $this->entities[$key] = $entity;
    }

    /**
     * @param $entity
     * @return bool
     */
    public function isValid($entity): bool
    {
        if (!is_object($entity)) return false;

        $entityClass = $this->allowEntitiesChildren ? get_parent_class($entity) : get_class($entity);
        if ($entityClass === static::entityClass()){
            return true;
        }

        return false;
    }

    /**
     * @return array
     */
    public function keys(): array
    {
        return array_keys($this->entities);
    }

    /**
     * @return array
     */
    public function values(): array
    {
        return array_values($this->entities);
    }

    /**
     * @return mixed
     */
    public function first()
    {
        return reset($this->entities);
    }

    /**
     * @return mixed
     */
    public function last()
    {
        return end($this->entities);
    }

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

    /**
     * @param int  $offset
     * @param null $length
     * @return static
     * @throws \Exception
     */
    public function slice(int $offset, $length = null)
    {
        $entities = array_slice($this->entities, $offset, $length, true);
        if (empty($entities)) {
            throw static::customEmptyException();
        }

        return new static($entities);
    }

    /**
     * @return mixed
     */
    public function current()
    {
        return current($this->entities);
    }

    /**
     * @return mixed
     */
    public function next()
    {
        return next($this->entities);
    }

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

    /**
     * @return bool
     */
    public function valid(): bool
    {
        return key($this->entities) !== null;
    }

    public function rewind()
    {
        reset($this->entities);
    }

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

    /**
     * @return \Exception
     */
    public static function customEmptyException(): \Exception
    {
        return new \LengthException('Collection can not be empty');
    }

    /**
     * @return \Exception
     */
    public static function customInvalidEntityException(): \Exception
    {
        return new \UnexpectedValueException('Element is not valid instance of '.static::entityClass());
    }
}