Roave\BackwardCompatibility\Changes

Complexity

Total Complexity

8

Size/Duplication

Total Lines	58
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

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

<?php

declare(strict_types=1);

namespace Roave\BackwardCompatibility;

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

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

    private function __construct()
    {
    }

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

        if ($empty) {
            return $empty;
        }

        $empty = new self();

        $empty->changes = [];

        return $empty;
    }

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

        $instance->changes = $changes;

        return $instance;
    }

    public function mergeWith(self $other) : self
    {
        if (! $other->changes) {

The expression $other->changes of type Roave\BackwardCompatibility\Change[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return $this;
        }

        return self::fromList(...$this->changes, ...$other->changes);
    }

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

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