Railt\Compiler\Grammar\LookaheadIterator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	toIterator()	0	4	2
A	current()	0	4	1
A	key()	0	4	1
A	rewind()	0	6	1
A	next()	0	14	2
A	valid()	0	4	1
A	hasNext()	0	4	1
A	getNext()	0	4	1
A	getNextKey()	0	4	1

<?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\Compiler\Grammar;

/**
 * Class LookaheadIterator
 */
class LookaheadIterator extends \IteratorIterator
{
    /**
     * Current key.
     *
     * @var mixed
     */
    protected $key = 0;

    /**
     * Current value.
     *
     * @var mixed
     */
    protected $current;

    /**
     * Whether the current element is valid or not.
     *
     * @var bool
     */
    protected $valid = false;

    /**
     * LookaheadIterator constructor.
     * @param iterable $iterator
     */
    public function __construct(iterable $iterator)
    {
        parent::__construct($this->toIterator($iterator));
        $this->rewind();
    }

    /**
     * @param iterable $iterable
     * @return \Traversable
     */
    private function toIterator(iterable $iterable): \Traversable
    {
        return $iterable instanceof \Traversable ? $iterable : new \ArrayIterator($iterable);
    }

    /**
     * Return the current element.
     *
     * @return mixed
     */
    public function current()
    {
        return $this->current;
    }

    /**
     * Return the key of the current element.
     *
     * @return mixed
     */
    public function key()
    {
        return $this->key;
    }

    /**
     * Rewind the iterator to the first element.
     *
     * @return void
     */
    public function rewind(): void
    {
        $this->getInnerIterator()->rewind();

        $this->next();
    }

    /**
     * Move forward to next element.
     *
     * @return void
     */
    public function next(): void
    {
        $innerIterator = $this->getInnerIterator();
        $this->valid   = $innerIterator->valid();

        if ($this->valid === false) {
            return;
        }

        $this->key     = $innerIterator->key();
        $this->current = $innerIterator->current();

        $innerIterator->next();
    }

    /**
     * Check if current position is valid.
     *
     * @return bool
     */
    public function valid(): bool
    {
        return $this->valid;
    }

    /**
     * Check whether there is a next element.
     *
     * @return bool
     */
    public function hasNext(): bool
    {
        return $this->getInnerIterator()->valid();
    }

    /**
     * Get next value.
     *
     * @return mixed
     */
    public function getNext()
    {
        return $this->getInnerIterator()->current();
    }

    /**
     * Get next key.
     *
     * @return mixed
     */
    public function getNextKey()
    {
        return $this->getInnerIterator()->key();
    }
}