Linio\Collection\FixedTypedCollection

Complexity

Total Complexity

16

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	offsetSet()	0	5	1
A	get()	0	8	2
A	offsetGet()	0	4	1
A	add()	0	5	1
A	validateSize()	0	6	2
C	matching()	0	29	7

<?php

declare(strict_types=1);

namespace Linio\Collection;

use Doctrine\Common\Collections\Criteria;
use Doctrine\Common\Collections\Expr\ClosureExpressionVisitor;

abstract class FixedTypedCollection extends TypedCollection
{
    /**
     * @var int
     */
    protected $size;

    /**
     * @param int   $size
     * @param array $elements
     */
    public function __construct($size, array $elements = [])
    {
        $this->size = (int) $size;

        parent::__construct($elements);

        if ($this->count() > $this->size) {
            throw new \InvalidArgumentException('Index invalid or out of range');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        $this->validateSize();
        parent::offsetSet($offset, $value);
    }

    /**
     * @param int|string $key
     *
     * @throws \InvalidArgumentException
     *
     * @return mixed|null
     */
    public function get($key)
    {
        if (!$this->containsKey($key)) {
            throw new \InvalidArgumentException('Index invalid or out of range');
        }

        return parent::get($key);
    }

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

    /**
     * {@inheritdoc}
     */
    public function add($value)
    {
        $this->validateSize();
        parent::add($value);
    }

    /**
     * @throws \InvalidArgumentException
     */
    protected function validateSize()
    {
        if ($this->count() >= $this->size) {
            throw new \InvalidArgumentException('Index invalid or out of range');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function matching(Criteria $criteria)
    {
        $expr = $criteria->getWhereExpression();
        $filtered = $this->toArray();

        if ($expr) {
            $visitor = new ClosureExpressionVisitor();
            $filter = $visitor->dispatch($expr);
            $filtered = array_filter($filtered, $filter);
        }

        if ($orderings = $criteria->getOrderings()) {
            $next = null;
            foreach (array_reverse($orderings) as $field => $ordering) {
                $next = ClosureExpressionVisitor::sortByField($field, $ordering == 'DESC' ? -1 : 1, $next);
            }

            usort($filtered, $next);
        }

        $offset = $criteria->getFirstResult();
        $length = $criteria->getMaxResults();

        if ($offset || $length) {

The expression $offset of type integer|null is loosely compared to true; this is ambiguous if the integer can be zero. You might want to explicitly use !== null instead.

The expression $length of type integer|null is loosely compared to true; this is ambiguous if the integer can be zero. You might want to explicitly use !== null instead.

            $filtered = array_slice($filtered, (int) $offset, $length);
        }

        return new static(count($filtered), $filtered);
    }
}