Roave\BackwardCompatibility\Changes

Complexity

Total Complexity

14

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	fromList()	0	7	1
A	mergeWithIterator()	0	16	3
A	mergeWith()	0	3	1
A	__construct()	0	2	1
A	fromIterator()	0	12	2
A	count()	0	3	1
A	getIterator()	0	13	3
A	empty()	0	13	2

<?php

declare(strict_types=1);

namespace Roave\BackwardCompatibility;

use ArrayIterator;
use Countable;
use Generator;
use IteratorAggregate;
use function count;

final class Changes implements IteratorAggregate, Countable
{
    /** @var Change[] */
    private $changes;

    /** Generator|null */
    private $generator;

    private function __construct()
    {
    }

    public static function empty() : self
    {
        static $empty;

        if ($empty) {
            return $empty;
        }

        $empty = new self();

        $empty->changes = [];

        return $empty;
    }

    /** @param Change[] $changes */
    public static function fromIterator(iterable $changes) : self
    {
        $instance = new self();

        $instance->changes   = [];
        $instance->generator = (function () use ($changes) : Generator {
            foreach ($changes as $change) {
                yield $change;
            }
        })();

        return $instance;
    }

    /** @param Change[] $changes */
    public function mergeWithIterator(iterable $changes) : self
    {
        $instance = new self();

        $instance->changes   = [];
        $instance->generator = (function () use ($changes) : Generator {
            foreach ($this as $change) {
                yield $change;
            }

            foreach ($changes as $change) {
                yield $change;
            }
        })();

        return $instance;
    }

    public static function fromList(Change ...$changes) : self
    {
        $instance = new self();

        $instance->changes = $changes;

        return $instance;
    }

    public function mergeWith(self $other) : self
    {
        return $this->mergeWithIterator($other);
    }

    /**
     * {@inheritDoc}
     *
     * @return ArrayIterator|Change[]
     */
    public function getIterator() : iterable
    {
        foreach ($this->changes as $change) {
            yield $change;

The expression yield $change returns the type Generator which is incompatible with the documented return type Roave\BackwardCompatibility\Change[]&ArrayIterator.

        }

        foreach ($this->generator ?? [] as $change) {
            $this->changes[] = $change;

            yield $change;
        }

        $this->generator = null;
    }

    /**
     * {@inheritDoc}
     */
    public function count() : int
    {
        return count(iterator_to_array($this));
    }
}