Railt\SDL\Compiler\Pipeline

Complexity

Total Complexity

17

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

55%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getIterator()	0	6	2
A	next()	0	10	3
A	building()	0	4	1
A	extending()	0	4	1
A	resolving()	0	4	1
A	runtime()	0	4	1
A	push()	0	8	2
A	createList()	0	4	1
A	count()	0	6	1
A	pop()	0	10	2
A	reduce()	0	6	2

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\SDL\Compiler;

/**
 * Class Pipeline
 */
class Pipeline implements \IteratorAggregate, \Countable
{
    private const PRIORITY_BUILDING = 1;
    private const PRIORITY_EXTENSIONS = 2;
    private const PRIORITY_TYPE_RESOLVING = 3;
    private const PRIORITY_RUNTIME = 4;

    /**
     * Example struct:
     *
     * <code>
     *  [
     *      PRIORITY_1 => \SplQueue([1, 2, 3]),
     *      PRIORITY_2 => \SplQueue([1, 2, 3]),
     *      PRIORITY_3 => \SplQueue([1, 2, 3]),
     *  ]
     * </code>
     *
     * @var \SplQueue[]
     */
    private $queue = [];

    /**
     * @return \Traversable|callable[]
     */
    public function getIterator(): \Traversable
    {
        while ($next = $this->next()) {
            yield $next;
        }
    }

    /**
     * @return null|callable
     */
    private function next(): ?callable
    {
        foreach ($this->queue as $queue) {
            if ($queue->count() > 0) {
                return $queue->shift();
            }
        }

        return null;
    }

    /**
     * @param \Closure $then
     */
    public function building(\Closure $then): void
    {
        $this->push(self::PRIORITY_BUILDING, $then);
    }

    /**
     * @param \Closure $then
     */
    public function extending(\Closure $then): void
    {
        $this->push(self::PRIORITY_EXTENSIONS, $then);
    }

    /**
     * @param \Closure $then
     */
    public function resolving(\Closure $then): void
    {
        $this->push(self::PRIORITY_TYPE_RESOLVING, $then);
    }

    /**
     * @param \Closure $then
     */
    public function runtime(\Closure $then): void
    {
        $this->push(self::PRIORITY_RUNTIME, $then);
    }

    /**
     * @param int $priority
     * @param callable $then
     */
    public function push(int $priority, callable $then): void
    {
        if (! \array_key_exists($priority, $this->queue)) {
            $this->queue[$priority] = $this->createList();
        }

        $this->queue[$priority]->push($then);
    }

    /**
     * @return \SplDoublyLinkedList
     */
    protected function createList(): \SplDoublyLinkedList
    {
        return new \SplQueue();
    }

    /**
     * @return int
     */
    public function count(): int
    {
        return (int)\array_reduce($this->queue, function (int $result, \SplQueue $queue): int {
            return $result + $queue->count();
        }, 0);
    }

    /**
     * @return callable
     * @throws \UnderflowException
     */
    public function pop(): callable
    {
        $result = $this->next();

        if ($result === null) {
            throw new \UnderflowException('Can not fetch data from empty heap');
        }

        return $result;
    }

    /**
     * @param \Closure $each
     */
    public function reduce(\Closure $each): void
    {
        foreach ($this->getIterator() as $callback) {
            $each($callback);
        }
    }
}