Changes::fromIterator() - Code Metrics - Inspection of "Moved all BC compliance and `Changes` instance to..." - Roave/BackwardCompatibilityCheck - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#108)

by Marco

created 2018-09-02 19:00 UTC

Changes::fromIterator() A

↳ Parent: Changes

Complexity

Conditions	2
Paths	1

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	1
nop	1
dl	0
loc	12
rs	10
c	0
b	0
f	0

<?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;

        }

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

            yield $change;
        }

        $this->generator = null;
    }

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


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Roave\BackwardCompatibility;
6
7			use ArrayIterator;
8			use Countable;
9			use Generator;
10			use IteratorAggregate;
11			use function count;
12
13			final class Changes implements IteratorAggregate, Countable
14			{
15			/** @var Change[] */
16			private $changes;
17
18			/** Generator\|null */
19			private $generator;
20
21			private function __construct()
22			{
23			}
24
25			public static function empty() : self
26			{
27			static $empty;
28
29			if ($empty) {
30			return $empty;
31			}
32
33			$empty = new self();
34
35			$empty->changes = [];
36
37			return $empty;
38			}
39
40			/** @param Change[] $changes */
41			public static function fromIterator(iterable $changes) : self
42			{
43			$instance = new self();
44
45			$instance->changes = [];
46			$instance->generator = (function () use ($changes) : Generator {
47			foreach ($changes as $change) {
48			yield $change;
49			}
50			})();
51
52			return $instance;
53			}
54
55			/** @param Change[] $changes */
56			public function mergeWithIterator(iterable $changes) : self
57			{
58			$instance = new self();
59
60			$instance->changes = [];
61			$instance->generator = (function () use ($changes) : Generator {
62			foreach ($this as $change) {
63			yield $change;
64			}
65
66			foreach ($changes as $change) {
67			yield $change;
68			}
69			})();
70
71			return $instance;
72			}
73
74			public static function fromList(Change ...$changes) : self
75			{
76			$instance = new self();
77
78			$instance->changes = $changes;
79
80			return $instance;
81			}
82
83			public function mergeWith(self $other) : self
84			{
85			return $this->mergeWithIterator($other);
86			}
87
88			/**
89			* {@inheritDoc}
90			*
91			* @return ArrayIterator\|Change[]
92			*/
93			public function getIterator() : iterable
94			{
95			foreach ($this->changes as $change) {
96			yield $change;
			0 ignored issues – show Bug Best Practice introduced 2018-09-02 19:04 UTC by Report Bug Copy Issue Report The expression `yield $change` returns the type `Generator` which is incompatible with the documented return type `Roave\BackwardCompatibil...\Change[]&ArrayIterator`. Loading history...
97			}
98
99			foreach ($this->generator ?? [] as $change) {
100			$this->changes[] = $change;
101
102			yield $change;
103			}
104
105			$this->generator = null;
106			}
107
108			/**
109			* {@inheritDoc}
110			*/
111			public function count() : int
112			{
113			return count(iterator_to_array($this));
114			}
115			}
116

Roave / BackwardCompatibilityCheck

Pull Request — master (#108)

Changes::fromIterator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like