OrderedMap::remove() - Code Metrics - Inspection of "Update to latest nikic/php-parser" - TimeToogo/Pinq - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9000d2...f19783 )

by Time

created 2015-12-31 01:42 UTC

OrderedMap::remove() B

↳ Parent: OrderedMap

Complexity

Conditions	4
Paths	5

Size

Total Lines	26
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	26
rs	8.5806
cc	4
eloc	15
nc	5
nop	1

<?php

namespace Pinq\Iterators\Common;

/**
 * Contains the common functionality for the IOrderedMap implementation.
 *
 * @author Elliot Levin <[email protected]>
 */
trait OrderedMap
{
    /**
     * @var array
     */
    protected $keys = [];

    /**
     * @var array
     */
    protected $values = [];

    /**
     * @var array
     */
    protected $keyIdentityPositionMap = [];

    /**
     * @var int
     */
    protected $length = 0;

    /**
     * @var int
     */
    protected $largestIntKey = -1;

    /**
     * {@inheritDoc}
     */
    public function keys()
    {
        return $this->keys;
    }

    /**
     * {@inheritDoc}
     */
    public function values()
    {
        return $this->values;
    }

    /**
     * {@inheritDoc}
     */
    public function map(callable $function)
    {
        $function = Functions::allowExcessiveArguments($function);

        $clone = clone $this;

        foreach ($clone->keyIdentityPositionMap as $position) {
            $keyCopy                  = $this->keys[$position];
            $valueCopy                = $this->values[$position];
            $clone->values[$position] = $function($valueCopy, $keyCopy);
        }

        return $clone;
    }

    /**
     * {@inheritDoc}
     */
    public function walk(callable $function)
    {
        $function = Functions::allowExcessiveArguments($function);

        foreach ($this->keys as $position => $key) {
            $function($this->values[$position], $key);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function groupBy(callable $groupKeyFunction)
    {
        $groupedMap = new self();

        foreach ($this->keyIdentityPositionMap as $identityHash => $position) {
            $keyCopy   = $key = $this->keys[$position];
            $valueCopy = $value =& $this->values[$position];

            $groupKey = $groupKeyFunction($valueCopy, $keyCopy);

            if ($groupedMap->contains($groupKey)) {
                $groupMap = $groupedMap->get($groupKey);
            } else {
                $groupMap = new self();
                $groupedMap->set($groupKey, $groupMap);
            }

            $groupMap->setInternal($key, $value, $identityHash, true);
        }

        return $groupedMap;
    }

    /**
     * {@inheritDoc}
     */
    public function multisort(array $orderByFunctions, array $isAscending)
    {
        $positionKeyIdentityMap = [];
        $multisortArguments     = [];

        foreach ($this->keyIdentityPositionMap as $keyIdentityHash => $position) {
            $positionKeyIdentityMap['0' . $position] = $keyIdentityHash;
        }

        foreach ($orderByFunctions as $key => $function) {
            $orderByValues = [];

            foreach ($this->keyIdentityPositionMap as $position) {
                $orderByValues['0' . $position] = $function($this->values[$position], $this->keys[$position]);
            }

            $multisortArguments[] =& $orderByValues;
            $multisortArguments[] = $isAscending[$key] ? SORT_ASC : SORT_DESC;
            $multisortArguments[] = SORT_REGULAR;

            unset($orderByValues);
        }

        $multisortArguments[] =& $positionKeyIdentityMap;

        call_user_func_array('array_multisort', $multisortArguments);

        $sortedMap = new self();

        $newPosition = 0;
        foreach ($positionKeyIdentityMap as $stringPosition => $keyIdentityHash) {
            $originalPosition = (int) $stringPosition;

            $sortedMap->keyIdentityPositionMap[$keyIdentityHash] = $newPosition;
            $sortedMap->keys[$newPosition]                       = $this->keys[$originalPosition];
            $sortedMap->values[$newPosition]                     =& $this->values[$originalPosition];

            $newPosition++;
        }

        return $sortedMap;
    }

    public function count()
    {
        return $this->length;
    }

    private function loadLargestIntKey()
    {
        $this->largestIntKey = -1;
        foreach ($this->keys as $key) {
            if (is_int($key) && $key > $this->largestIntKey) {
                $this->largestIntKey = $key;
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public function &get($key)
    {
        $identityHash = Identity::hash($key);

        if (isset($this->keyIdentityPositionMap[$identityHash])) {
            return $this->values[$this->keyIdentityPositionMap[$identityHash]];
        } else {
            $null = null;

            return $null;
        }
    }

    /**
     * {@inheritDoc}
     */
    public function contains($key)
    {
        return isset($this->keyIdentityPositionMap[Identity::hash($key)]);
    }

    /**
     * {@inheritDoc}
     */
    public function set($key, $value)
    {
        $this->setInternal($key, $value, Identity::hash($key));
    }

    /**
     * {@inheritDoc}
     */
    public function setRef($key, &$value)
    {
        $this->setInternal($key, $value, Identity::hash($key), true);
    }

    final protected function setInternal($key, &$value, $identityHash, $reference = false)
    {
        if (isset($this->keyIdentityPositionMap[$identityHash])) {
            $position = $this->keyIdentityPositionMap[$identityHash];
        } else {
            $position                                    = $this->length++;
            $this->keyIdentityPositionMap[$identityHash] = $position;
        }
        if (is_int($key) && $key > $this->largestIntKey) {
            $this->largestIntKey = $key;
        }

        $this->keys[$position] = $key;
        if ($reference) {
            $this->values[$position] =& $value;
        } else {
            $this->values[$position] = $value;
        }
    }

    /**
     * {@inheritDoc}
     */
    public function remove($key)
    {
        $identityHash = Identity::hash($key);

        if (isset($this->keyIdentityPositionMap[$identityHash])) {
            $position = $this->keyIdentityPositionMap[$identityHash];

            unset($this->keys[$position],
            $this->values[$position],
            $this->keyIdentityPositionMap[$identityHash]);

            if ($position !== $this->length) {
                $this->keys   = array_values($this->keys);
                $this->values = array_values($this->values);
            }
            $this->length--;

            if ($key === $this->largestIntKey) {
                $this->loadLargestIntKey();
            }

            return true;
        }

        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function clear()
    {
        $this->keyIdentityPositionMap = [];
        $this->keys                   = [];
        $this->values                 = [];
        $this->length                 = 0;
        $this->largestIntKey          = -1;
    }

    public function offsetExists($offset)
    {
        return $this->contains($offset);
    }

    public function &offsetGet($offset)
    {
        return $this->get($offset);
    }

    public function offsetSet($offset, $value)
    {
        if ($offset === null) {
            $offset = ++$this->largestIntKey;
        }
        $this->set($offset, $value);
    }

    public function offsetUnset($offset)
    {
        return $this->remove($offset);
    }

    /**
     * @return bool
     */
    final public function isArrayCompatible()
    {
        return false;
    }
}


1			<?php
2
3			namespace Pinq\Iterators\Common;
4
5			/**
6			* Contains the common functionality for the IOrderedMap implementation.
7			*
8			* @author Elliot Levin <[email protected]>
9			*/
10			trait OrderedMap
11			{
12			/**
13			* @var array
14			*/
15			protected $keys = [];
16
17			/**
18			* @var array
19			*/
20			protected $values = [];
21
22			/**
23			* @var array
24			*/
25			protected $keyIdentityPositionMap = [];
26
27			/**
28			* @var int
29			*/
30			protected $length = 0;
31
32			/**
33			* @var int
34			*/
35			protected $largestIntKey = -1;
36
37			/**
38			* {@inheritDoc}
39			*/
40			public function keys()
41			{
42			return $this->keys;
43			}
44
45			/**
46			* {@inheritDoc}
47			*/
48			public function values()
49			{
50			return $this->values;
51			}
52
53			/**
54			* {@inheritDoc}
55			*/
56			public function map(callable $function)
57			{
58			$function = Functions::allowExcessiveArguments($function);
59
60			$clone = clone $this;
61
62			foreach ($clone->keyIdentityPositionMap as $position) {
63			$keyCopy = $this->keys[$position];
64			$valueCopy = $this->values[$position];
65			$clone->values[$position] = $function($valueCopy, $keyCopy);
66			}
67
68			return $clone;
69			}
70
71			/**
72			* {@inheritDoc}
73			*/
74			public function walk(callable $function)
75			{
76			$function = Functions::allowExcessiveArguments($function);
77
78			foreach ($this->keys as $position => $key) {
79			$function($this->values[$position], $key);
80			}
81			}
82
83			/**
84			* {@inheritDoc}
85			*/
86			public function groupBy(callable $groupKeyFunction)
87			{
88			$groupedMap = new self();
89
90			foreach ($this->keyIdentityPositionMap as $identityHash => $position) {
91			$keyCopy = $key = $this->keys[$position];
92			$valueCopy = $value =& $this->values[$position];
93
94			$groupKey = $groupKeyFunction($valueCopy, $keyCopy);
95
96			if ($groupedMap->contains($groupKey)) {
97			$groupMap = $groupedMap->get($groupKey);
98			} else {
99			$groupMap = new self();
100			$groupedMap->set($groupKey, $groupMap);
101			}
102
103			$groupMap->setInternal($key, $value, $identityHash, true);
104			}
105
106			return $groupedMap;
107			}
108
109			/**
110			* {@inheritDoc}
111			*/
112			public function multisort(array $orderByFunctions, array $isAscending)
113			{
114			$positionKeyIdentityMap = [];
115			$multisortArguments = [];
116
117			foreach ($this->keyIdentityPositionMap as $keyIdentityHash => $position) {
118			$positionKeyIdentityMap['0' . $position] = $keyIdentityHash;
119			}
120
121			foreach ($orderByFunctions as $key => $function) {
122			$orderByValues = [];
123
124			foreach ($this->keyIdentityPositionMap as $position) {
125			$orderByValues['0' . $position] = $function($this->values[$position], $this->keys[$position]);
126			}
127
128			$multisortArguments[] =& $orderByValues;
129			$multisortArguments[] = $isAscending[$key] ? SORT_ASC : SORT_DESC;
130			$multisortArguments[] = SORT_REGULAR;
131
132			unset($orderByValues);
133			}
134
135			$multisortArguments[] =& $positionKeyIdentityMap;
136
137			call_user_func_array('array_multisort', $multisortArguments);
138
139			$sortedMap = new self();
140
141			$newPosition = 0;
142			foreach ($positionKeyIdentityMap as $stringPosition => $keyIdentityHash) {
143			$originalPosition = (int) $stringPosition;
144
145			$sortedMap->keyIdentityPositionMap[$keyIdentityHash] = $newPosition;
146			$sortedMap->keys[$newPosition] = $this->keys[$originalPosition];
147			$sortedMap->values[$newPosition] =& $this->values[$originalPosition];
148
149			$newPosition++;
150			}
151
152			return $sortedMap;
153			}
154
155			public function count()
156			{
157			return $this->length;
158			}
159
160			private function loadLargestIntKey()
161			{
162			$this->largestIntKey = -1;
163			foreach ($this->keys as $key) {
164			if (is_int($key) && $key > $this->largestIntKey) {
165			$this->largestIntKey = $key;
166			}
167			}
168			}
169
170			/**
171			* {@inheritDoc}
172			*/
173			public function &get($key)
174			{
175			$identityHash = Identity::hash($key);
176
177			if (isset($this->keyIdentityPositionMap[$identityHash])) {
178			return $this->values[$this->keyIdentityPositionMap[$identityHash]];
179			} else {
180			$null = null;
181
182			return $null;
183			}
184			}
185
186			/**
187			* {@inheritDoc}
188			*/
189			public function contains($key)
190			{
191			return isset($this->keyIdentityPositionMap[Identity::hash($key)]);
192			}
193
194			/**
195			* {@inheritDoc}
196			*/
197			public function set($key, $value)
198			{
199			$this->setInternal($key, $value, Identity::hash($key));
200			}
201
202			/**
203			* {@inheritDoc}
204			*/
205			public function setRef($key, &$value)
206			{
207			$this->setInternal($key, $value, Identity::hash($key), true);
208			}
209
210			final protected function setInternal($key, &$value, $identityHash, $reference = false)
211			{
212			if (isset($this->keyIdentityPositionMap[$identityHash])) {
213			$position = $this->keyIdentityPositionMap[$identityHash];
214			} else {
215			$position = $this->length++;
216			$this->keyIdentityPositionMap[$identityHash] = $position;
217			}
218			if (is_int($key) && $key > $this->largestIntKey) {
219			$this->largestIntKey = $key;
220			}
221
222			$this->keys[$position] = $key;
223			if ($reference) {
224			$this->values[$position] =& $value;
225			} else {
226			$this->values[$position] = $value;
227			}
228			}
229
230			/**
231			* {@inheritDoc}
232			*/
233			public function remove($key)
234			{
235			$identityHash = Identity::hash($key);
236
237			if (isset($this->keyIdentityPositionMap[$identityHash])) {
238			$position = $this->keyIdentityPositionMap[$identityHash];
239
240			unset($this->keys[$position],
241			$this->values[$position],
242			$this->keyIdentityPositionMap[$identityHash]);
243
244			if ($position !== $this->length) {
245			$this->keys = array_values($this->keys);
246			$this->values = array_values($this->values);
247			}
248			$this->length--;
249
250			if ($key === $this->largestIntKey) {
251			$this->loadLargestIntKey();
252			}
253
254			return true;
255			}
256
257			return false;
258			}
259
260			/**
261			* {@inheritDoc}
262			*/
263			public function clear()
264			{
265			$this->keyIdentityPositionMap = [];
266			$this->keys = [];
267			$this->values = [];
268			$this->length = 0;
269			$this->largestIntKey = -1;
270			}
271
272			public function offsetExists($offset)
273			{
274			return $this->contains($offset);
275			}
276
277			public function &offsetGet($offset)
278			{
279			return $this->get($offset);
280			}
281
282			public function offsetSet($offset, $value)
283			{
284			if ($offset === null) {
285			$offset = ++$this->largestIntKey;
286			}
287			$this->set($offset, $value);
288			}
289
290			public function offsetUnset($offset)
291			{
292			return $this->remove($offset);
293			}
294
295			/**
296			* @return bool
297			*/
298			final public function isArrayCompatible()
299			{
300			return false;
301			}
302			}
303

TimeToogo / Pinq

GitHub Access Token became invalid

Push — master ( 9000d2...f19783 )

OrderedMap::remove() B

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like