GeneratorScheme::emptyIterator() - Code Metrics - TimeToogo/Pinq - Measure and Improve Code Quality continuously with Scrutinizer

GeneratorScheme::emptyIterator() A
last analyzed 2017-09-06 06:30 UTC

↳ Parent: GeneratorScheme

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Pinq\Iterators\Generators;

use Pinq\Iterators\Common;
use Pinq\Iterators\Standard\IIterator;

/**
 * Iterator scheme using rewindable generator implementations.
 * Compatible with >= PHP 5.5.0.
 *
 * @author Elliot Levin <[email protected]>
 */
class GeneratorScheme extends Common\IteratorScheme
{
    public static function compatibleWith($phpVersion)
    {
        // HHVM does not support foreach by reference on iterators.
        // This is used extensively by the generator classes,
        // hence fallback to the standard iterator scheme.
        return version_compare($phpVersion, '5.5.0', '>=')
                && strpos($phpVersion, 'hhvm') === false
                && strpos($phpVersion, 'hiphop') === false;
    }

    public function createOrderedMap(\Traversable $iterator = null)
    {
        return new OrderedMap($iterator === null ? null : $this->adapter($iterator));
    }

    public function createSet(\Traversable $iterator = null)
    {
        return new Set($iterator === null ? null : $this->adapter($iterator));
    }

    public function walk(\Traversable $iterator, callable $function)
    {
        $adapter = $this->adapter($iterator);
        foreach ($adapter as $key => &$value) {
            if ($function($value, $key) === false) {
                break;
            }
        }
    }

    public function toArray(\Traversable $iterator)
    {
        $iterator = $this->arrayCompatibleIterator($iterator);
        $array    = [];

        foreach ($iterator as $key => &$value) {
            $array[$key] =& $value;
        }

        return $array;
    }

    public function arrayCompatibleIterator(\Traversable $iterator)

    {
        $iterator = $this->adapter($iterator);
        if ($iterator->isArrayCompatible()) {
            return $iterator;
        }

        return new ArrayCompatibleIterator($this->adapter($iterator));
    }

    /**
     * @param \Traversable $iterator
     *
     * @return IGenerator
     */
    public static function adapter(\Traversable $iterator)
    {
        if ($iterator instanceof IGenerator) {
            return $iterator;
        } elseif ($iterator instanceof IIterator) {
            return new IIteratorAdapter($iterator);
        } elseif ($iterator instanceof \ArrayIterator) {
            return new ArrayIteratorAdapter($iterator);
        } elseif ($iterator instanceof \IteratorAggregate) {
            return static::adapter($iterator->getIterator());
        } else {
            return new IteratorAdapter($iterator);
        }
    }

    protected function adapterIterator(\Traversable $iterator)
    {
        return static::adapter($iterator);
    }

    public function arrayIterator(array $array)
    {
        return new ArrayIterator($array);
    }

    public function emptyIterator()
    {
        return new EmptyIterator();
    }

    public function filterIterator(\Traversable $iterator, callable $predicate)
    {
        return new FilterIterator($this->adapter($iterator), $predicate);
    }

    public function projectionIterator(
            \Traversable $iterator,
            callable $keyProjectionFunction = null,
            callable $valueProjectionFunction = null
    ) {
        return new ProjectionIterator(
                $this->adapter($iterator),
                $keyProjectionFunction,
                $valueProjectionFunction);
    }

    public function reindexerIterator(\Traversable $iterator)
    {
        return new ReindexedIterator($this->adapter($iterator));
    }

    public function joinIterator(\Traversable $outerIterator, \Traversable $innerIterator)
    {
        return new UnfilteredJoinIterator(
                $this->adapter($outerIterator),
                $this->adapter($innerIterator));
    }

    public function groupJoinIterator(
            \Traversable $outerIterator,
            \Traversable $innerIterator,
            callable $traversableFactory
    ) {
        return new UnfilteredGroupJoinIterator(
                $this->adapter($outerIterator),
                $this->adapter($innerIterator),
                $traversableFactory);
    }

    public function rangeIterator(\Traversable $iterator, $start, $amount)
    {
        return new RangeIterator($this->adapter($iterator), $start, $amount);
    }

    public function groupedIterator(
            \Traversable $iterator,
            callable $groupKeyFunction,
            callable $traversableFactory
    ) {
        return new GroupedIterator(
                $this->adapter($iterator),
                $groupKeyFunction,
                $traversableFactory);
    }

    public function orderedIterator(\Traversable $iterator, callable $function, $isAscending)
    {
        return new OrderedIterator(
                $this->adapter($iterator),
                $function,
                $isAscending);
    }

    protected function setOperationIterator(\Traversable $iterator, Common\SetOperations\ISetFilter $setFilter)
    {
        return new SetOperationIterator($this->adapter($iterator), $setFilter);
    }

    protected function flattenedIteratorsIterator(\Traversable $iteratorsIterator)
    {
        return new FlatteningIterator($this->adapter($iteratorsIterator));
    }
}


1		<?php
2
3		namespace Pinq\Iterators\Generators;
4
5		use Pinq\Iterators\Common;
6		use Pinq\Iterators\Standard\IIterator;
7
8		/**
9		* Iterator scheme using rewindable generator implementations.
10		* Compatible with >= PHP 5.5.0.
11		*
12		* @author Elliot Levin <[email protected]>
13		*/
14		class GeneratorScheme extends Common\IteratorScheme
15		{
16		public static function compatibleWith($phpVersion)
17		{
18		// HHVM does not support foreach by reference on iterators.
19		// This is used extensively by the generator classes,
20		// hence fallback to the standard iterator scheme.
21		return version_compare($phpVersion, '5.5.0', '>=')
22		&& strpos($phpVersion, 'hhvm') === false
23		&& strpos($phpVersion, 'hiphop') === false;
24		}
25
26		public function createOrderedMap(\Traversable $iterator = null)
27		{
28		return new OrderedMap($iterator === null ? null : $this->adapter($iterator));
29		}
30
31		public function createSet(\Traversable $iterator = null)
32		{
33		return new Set($iterator === null ? null : $this->adapter($iterator));
34		}
35
36		public function walk(\Traversable $iterator, callable $function)
37		{
38		$adapter = $this->adapter($iterator);
39		foreach ($adapter as $key => &$value) {
40		if ($function($value, $key) === false) {
41		break;
42		}
43		}
44		}
45
46		public function toArray(\Traversable $iterator)
47		{
48		$iterator = $this->arrayCompatibleIterator($iterator);
49		$array = [];
50
51		foreach ($iterator as $key => &$value) {
52		$array[$key] =& $value;
53		}
54
55		return $array;
56		}
57
58	View Code Duplication	public function arrayCompatibleIterator(\Traversable $iterator)
		0 ignored issues – show Duplication introduced 2017-09-06 06:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
59		{
60		$iterator = $this->adapter($iterator);
61		if ($iterator->isArrayCompatible()) {
62		return $iterator;
63		}
64
65		return new ArrayCompatibleIterator($this->adapter($iterator));
66		}
67
68		/**
69		* @param \Traversable $iterator
70		*
71		* @return IGenerator
72		*/
73	View Code Duplication	public static function adapter(\Traversable $iterator)
74		{
75		if ($iterator instanceof IGenerator) {
76		return $iterator;
77		} elseif ($iterator instanceof IIterator) {
78		return new IIteratorAdapter($iterator);
79		} elseif ($iterator instanceof \ArrayIterator) {
80		return new ArrayIteratorAdapter($iterator);
81		} elseif ($iterator instanceof \IteratorAggregate) {
82		return static::adapter($iterator->getIterator());
83		} else {
84		return new IteratorAdapter($iterator);
85		}
86		}
87
88		protected function adapterIterator(\Traversable $iterator)
89		{
90		return static::adapter($iterator);
91		}
92
93		public function arrayIterator(array $array)
94		{
95		return new ArrayIterator($array);
96		}
97
98		public function emptyIterator()
99		{
100		return new EmptyIterator();
101		}
102
103		public function filterIterator(\Traversable $iterator, callable $predicate)
104		{
105		return new FilterIterator($this->adapter($iterator), $predicate);
106		}
107
108		public function projectionIterator(
109		\Traversable $iterator,
110		callable $keyProjectionFunction = null,
111		callable $valueProjectionFunction = null
112		) {
113		return new ProjectionIterator(
114		$this->adapter($iterator),
115		$keyProjectionFunction,
116		$valueProjectionFunction);
117		}
118
119		public function reindexerIterator(\Traversable $iterator)
120		{
121		return new ReindexedIterator($this->adapter($iterator));
122		}
123
124		public function joinIterator(\Traversable $outerIterator, \Traversable $innerIterator)
125		{
126		return new UnfilteredJoinIterator(
127		$this->adapter($outerIterator),
128		$this->adapter($innerIterator));
129		}
130
131		public function groupJoinIterator(
132		\Traversable $outerIterator,
133		\Traversable $innerIterator,
134		callable $traversableFactory
135		) {
136		return new UnfilteredGroupJoinIterator(
137		$this->adapter($outerIterator),
138		$this->adapter($innerIterator),
139		$traversableFactory);
140		}
141
142		public function rangeIterator(\Traversable $iterator, $start, $amount)
143		{
144		return new RangeIterator($this->adapter($iterator), $start, $amount);
145		}
146
147		public function groupedIterator(
148		\Traversable $iterator,
149		callable $groupKeyFunction,
150		callable $traversableFactory
151		) {
152		return new GroupedIterator(
153		$this->adapter($iterator),
154		$groupKeyFunction,
155		$traversableFactory);
156		}
157
158		public function orderedIterator(\Traversable $iterator, callable $function, $isAscending)
159		{
160		return new OrderedIterator(
161		$this->adapter($iterator),
162		$function,
163		$isAscending);
164		}
165
166		protected function setOperationIterator(\Traversable $iterator, Common\SetOperations\ISetFilter $setFilter)
167		{
168		return new SetOperationIterator($this->adapter($iterator), $setFilter);
169		}
170
171		protected function flattenedIteratorsIterator(\Traversable $iteratorsIterator)
172		{
173		return new FlatteningIterator($this->adapter($iteratorsIterator));
174		}
175		}
176

TimeToogo / Pinq

GitHub Access Token became invalid

GeneratorScheme::emptyIterator() A last analyzed 2017-09-06 06:30 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GeneratorScheme::emptyIterator() A
last analyzed 2017-09-06 06:30 UTC