mav3rick177\RapidPagination\Base\Query\ConditionGroup

Complexity

Total Complexity

13

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

81.58%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	createMany()	0	25	2
A	create()	0	24	5
A	__construct()	0	4	1
A	validate()	0	4	1
A	conditions()	0	4	1
A	inverse()	0	6	1
A	__clone()	0	6	1
A	getIterator()	0	4	1

<?php

namespace mav3rick177\RapidPagination\Base\Query;

use mav3rick177\RapidPagination\Base\Contracts\Cursor;
use mav3rick177\RapidPagination\Base\ArrayCursor;
use mav3rick177\RapidPagination\Base\Exceptions\Query\CursorParameterException;

/**
 * Class ConditionGroup
 *
 * Conditions are concatenated with "AND".
 */
class ConditionGroup implements \IteratorAggregate
{
    /**
     * @var Condition[]
     */
    protected $conditions = [];

    /**
     * @param  Order[]               $orders
     * @param  Cursor|int[]|string[] $cursor
     * @param  Direction             $direction
     * @param  bool                  $exclusive
     * @param  bool                  $isSupportQuery
     * @return static[]
     */
    public static function createMany(array $orders, $cursor, Direction $direction, $exclusive, $isSupportQuery = false)
    {
        $groups = [];
        $count = count($orders);
        for ($i = 0; $i < $count; ++$i) {
            /*
             * Slice orders for building conditions.
             *
             * e.g.
             *
             *    1st:  updated_at = ? AND created_at = ? AND id > ?
             *    2nd:  updated_at = ? AND created_at > ?
             *    3rd:  updated_at > ?
             */
            $groups[] = static::create(
                array_slice($orders, 0, $count - $i),
                $cursor,
                $direction,
                $exclusive,
                $i === 0, // First row has a primary key
                $isSupportQuery
            );
        }
        return $groups;
    }

    /**
     * @param  Order[]               $orders
     * @param  Cursor|int[]|string[] $cursor
     * @param  Direction             $direction
     * @param  bool                  $exclusive
     * @param  bool                  $hasPrimaryKey
     * @param  bool                  $isSupportQuery
     * @return static
     */
    public static function create(array $orders, $cursor, Direction $direction, $exclusive, $hasPrimaryKey, $isSupportQuery = false)
    {
        $conditions = [];
        $i = 0;
        $count = count($orders);
        $cursor = $cursor instanceof Cursor ? $cursor : new ArrayCursor($cursor);
        foreach ($orders as $order) {
            if (!$cursor->has($order->column())) {
                // All parameters must be specified.
                throw new CursorParameterException("Missing cursor parameter: {$order->column()}", $order->column());
            }
            $isLastKey = ++$i === $count;
            $conditions[] = Condition::create(
                $order,
                $cursor->get($order->column()),
                $direction,
                $exclusive,
                $isLastKey && $hasPrimaryKey, // When it is the last key and we have a primary key, it is also the primary key.
                $isLastKey,
                $isSupportQuery
            );
        }
        return new static($conditions);
    }

    /**
     * Group constructor.
     *
     * @param Condition[] $conditions
     */
    public function __construct(array $conditions)
    {
        $this->conditions = static::validate(...$conditions);

It seems like static::validate(...$conditions) of type array<integer,array<integer,object<mav3rick177\RapidPagination\Base\Query\Condition>>> is incompatible with the declared type array<integer,object<mav3rick177\RapidPagination\Base\Query\Condition>> of property $conditions.

    }

    /**
     * @param  Condition[] $conditions
     * @return Condition[]
     */
    protected static function validate(Condition ...$conditions)
    {
        return $conditions;
    }

    /**
     * @return Condition[]
     */
    public function conditions()
    {
        return $this->conditions;
    }

    /**
     * @return static
     */
    public function inverse()
    {
        return new static(array_map(static function (Condition $condition) {
            return $condition->inverse();
        }, $this->conditions));
    }

    /**
     * Clone Group.
     */
    public function __clone()
    {
        $this->conditions = array_map(static function (Condition $condition) {
            return clone $condition;
        }, $this->conditions);
    }

    /**
     * Retrieve an external iterator.
     *
     * @return \ArrayIterator|Condition[]
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->conditions);
    }
}