Arrayed::validIndex() - Code Metrics - Inspection of "DoublyLinkedList update" - MBHFramework/structures - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.x ( 650a57...b30111 )

by Ulises Jeremias

created 2018-01-01 05:12 UTC

Arrayed::validIndex() A

↳ Parent: Arrayed

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php namespace Mbh\Collection\Traits\Sequenceable;

use Mbh\Collection\Interfaces\Collection as CollectionInterface;
use Mbh\Collection\Interfaces\Sequenceable as SequenceableInterface;
use Mbh\Collection\FixedArray;
use Mbh\Collection\CallbackHeap;
use Mbh\Iterator\SliceIterator;
use Mbh\Iterator\ConcatIterator;
use Mbh\Collection\Traits\Builder;
use SplFixedArray;
use SplHeap;
use SplStack;
use LimitIterator;
use Iterator;
use ArrayAccess;
use Countable;
use CallbackFilterIterator;
use JsonSerializable;
use RuntimeException;
use Traversable;
use ReflectionClass;
use UnderflowException;
use OutOfRangeException;

/**
 * MBHFramework
 *
 * @link      https://github.com/MBHFramework/mbh-framework
 * @copyright Copyright (c) 2017 Ulises Jeremias Cornejo Fandos
 * @license   https://github.com/MBHFramework/mbh-framework/blob/master/LICENSE (MIT License)
 */

trait Arrayed
{
    use Arrayed\Countable;
    use Arrayed\ArrayAccess;
    use Arrayed\Iterator;
    use Builder;

    protected $sfa = null;

    /**
     * Create an fixed array
     *
     * @param Traversable $array data
     */
    protected function __construct(Traversable $array)
    {
        $this->sfa = $array;
        $this->checkCapacity();
    }

    /**
     * @inheritDoc
     */
    public function contains(...$values): bool
    {
        foreach ($values as $value) {
            if ($this->search($value) !== null) {
                return false;
            }
        }

        return true;
    }

    /**
     * @inheritDoc
     */
    public function copy()
    {
        return static::fromArray($this->toArray());
    }

    /**
     * @inheritDoc
     */
    public function first()
    {
        $this->emptyGuard(__METHOD__);
        return $this[0];
    }

    /**
     * @inheritDoc
     */
    public function get(int $index)
    {
        if (!$this->validIndex($index)) {
            throw new OutOfRangeException();
        }

        return $this[$index];
    }

    /**
     * @inheritDoc
     */
    public function insert(int $index, ...$values)
    {
        if (!$this->validIndex($index) && $index !== $this->count()) {
            throw new OutOfRangeException();
        }

        $splice = $this->splice($index, 0, $values);
        $this->clear();

        $this->pushAll($splice);
    }

    /**
     * @inheritDoc
     */
    public function last()
    {
        $this->emptyGuard(__METHOD__);
        return $this[$this->count() - 1];
    }

    /**
     * Converts negative or large rotations into the minimum positive number
     * of rotations required to rotate the sequence by a given $r.
     */
    private function normalizeRotations(int $r)
    {
        $n = $this->count();

        if ($n < 2) {
            return 0;
        }

        if ($r < 0) {
            return $n - (abs($r) % $n);
        }

        return $r % $n;
    }

    /**
     * @inheritDoc
     */
    public function pop()
    {
        $this->emptyGuard(__METHOD__);
        $value = $this->last();
        $count = $this->count();
        unset($this[--$count]);
        $this->setSize($count);

        $this->checkCapacity();

        return $value;
    }

    /**
     * Pushes all values of either an array or traversable object.
     */
    private function pushAll(...$args)
    {
        $size = $this->getSize();

        foreach ($args as &$values) {
            $this->setSize($size + count($values));

            foreach ($values as $value) {
                $this[$size++] = $value;
            }
        }

        $this->checkCapacity();
    }

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

    /**
     * @inheritDoc
     */
    public function remove(int $index)
    {
        if (!$this->validIndex($index)) {
            throw new OutOfRangeException();
        }

        $value = $this[$index];
        $splice = $this->splice($index + 1, 1, null);
        $this->clear();

        $this->pushAll($splice);
        return $value;
    }

    /**
     * @inheritDoc
     */
    public function set(int $index, $value)
    {
        if (!$this->validIndex($index)) {
            throw new OutOfRangeException();
        }

        $this->sfa->offsetSet($index, $value);
    }

    /**
     * @inheritDoc
     */
    public function shift()
    {
        $this->emptyGuard(__METHOD__);
        $value = $this->first();
        unset($this[0]);

        $this->checkCapacity();

        return $value;
    }

    /**
     * @inheritDoc
     */
    public function toArray(): array
    {
        return $this->sfa->toArray();
    }

    /**
     * @inheritDoc
     */
    public function unshift(...$values)
    {
        $this->insert(0, ...$values);

        return $this->count();
    }

    /**
     * @inheritDoc
     */
    public function unserialize($values)
    {
        $values = unserialize($values);
        $this->setValues(SplFixedArray::fromArray($values));
    }

    /**
     * @inheritDoc
     */
    protected function validIndex(int $index)
    {
        return $index >= 0 && $index < $this->getSize();
    }

    /**
     * @inheritDoc
     */
    public function clear()
    {
        $this->sfa->setSize(0);
        $this->checkCapacity();
    }

    protected function getValues(): Traversable
    {
        return $this->sfa;
    }

    protected function setValues(Traversable $traversable)
    {
        $this->clear();
        $this->pushAll($traversable);
    }

    /**
     * Gets the size of the array.
     *
     * @return int
     */
    protected function getSize(): int
    {
        return $this->sfa->getSize();
    }

    /**
     * Change the size of an array to the new size of size.
     * If size is less than the current array size, any values after the
     * new size will be discarded. If size is greater than the current
     * array size, the array will be padded with NULL values.
     *
     * @param int $size The new array size. This should be a value between 0
     * and PHP_INT_MAX.
     * @return bool Returns TRUE on success or FALSE on failure.
     */
    protected function setSize(int $size): bool
    {
        return $this->sfa->setSize($size);
    }

    public function __clone()
    {
        return $this->copy();
    }

    abstract protected function checkCapacity();

    abstract protected function emptyGuard($method);

    abstract public function isEmpty(): bool;

    abstract public function search($value);

    abstract public function splice(int $begin = 0, int $length = null, $replacement = []);
}


1			<?php namespace Mbh\Collection\Traits\Sequenceable;
2
3			use Mbh\Collection\Interfaces\Collection as CollectionInterface;
4			use Mbh\Collection\Interfaces\Sequenceable as SequenceableInterface;
5			use Mbh\Collection\FixedArray;
6			use Mbh\Collection\CallbackHeap;
7			use Mbh\Iterator\SliceIterator;
8			use Mbh\Iterator\ConcatIterator;
9			use Mbh\Collection\Traits\Builder;
10			use SplFixedArray;
11			use SplHeap;
12			use SplStack;
13			use LimitIterator;
14			use Iterator;
15			use ArrayAccess;
16			use Countable;
17			use CallbackFilterIterator;
18			use JsonSerializable;
19			use RuntimeException;
20			use Traversable;
21			use ReflectionClass;
22			use UnderflowException;
23			use OutOfRangeException;
24
25			/**
26			* MBHFramework
27			*
28			* @link https://github.com/MBHFramework/mbh-framework
29			* @copyright Copyright (c) 2017 Ulises Jeremias Cornejo Fandos
30			* @license https://github.com/MBHFramework/mbh-framework/blob/master/LICENSE (MIT License)
31			*/
32
33			trait Arrayed
34			{
35			use Arrayed\Countable;
36			use Arrayed\ArrayAccess;
37			use Arrayed\Iterator;
38			use Builder;
39
40			protected $sfa = null;
41
42			/**
43			* Create an fixed array
44			*
45			* @param Traversable $array data
46			*/
47			protected function __construct(Traversable $array)
48			{
49			$this->sfa = $array;
50			$this->checkCapacity();
51			}
52
53			/**
54			* @inheritDoc
55			*/
56			public function contains(...$values): bool
57			{
58			foreach ($values as $value) {
59			if ($this->search($value) !== null) {
60			return false;
61			}
62			}
63
64			return true;
65			}
66
67			/**
68			* @inheritDoc
69			*/
70			public function copy()
71			{
72			return static::fromArray($this->toArray());
73			}
74
75			/**
76			* @inheritDoc
77			*/
78			public function first()
79			{
80			$this->emptyGuard(__METHOD__);
81			return $this[0];
82			}
83
84			/**
85			* @inheritDoc
86			*/
87			public function get(int $index)
88			{
89			if (!$this->validIndex($index)) {
90			throw new OutOfRangeException();
91			}
92
93			return $this[$index];
94			}
95
96			/**
97			* @inheritDoc
98			*/
99			public function insert(int $index, ...$values)
100			{
101			if (!$this->validIndex($index) && $index !== $this->count()) {
102			throw new OutOfRangeException();
103			}
104
105			$splice = $this->splice($index, 0, $values);
106			$this->clear();
107
108			$this->pushAll($splice);
109			}
110
111			/**
112			* @inheritDoc
113			*/
114			public function last()
115			{
116			$this->emptyGuard(__METHOD__);
117			return $this[$this->count() - 1];
118			}
119
120			/**
121			* Converts negative or large rotations into the minimum positive number
122			* of rotations required to rotate the sequence by a given $r.
123			*/
124			private function normalizeRotations(int $r)
125			{
126			$n = $this->count();
127
128			if ($n < 2) {
129			return 0;
130			}
131
132			if ($r < 0) {
133			return $n - (abs($r) % $n);
134			}
135
136			return $r % $n;
137			}
138
139			/**
140			* @inheritDoc
141			*/
142			public function pop()
143			{
144			$this->emptyGuard(__METHOD__);
145			$value = $this->last();
146			$count = $this->count();
147			unset($this[--$count]);
148			$this->setSize($count);
149
150			$this->checkCapacity();
151
152			return $value;
153			}
154
155			/**
156			* Pushes all values of either an array or traversable object.
157			*/
158			private function pushAll(...$args)
159			{
160			$size = $this->getSize();
161
162			foreach ($args as &$values) {
163			$this->setSize($size + count($values));
164
165			foreach ($values as $value) {
166			$this[$size++] = $value;
167			}
168			}
169
170			$this->checkCapacity();
171			}
172
173			/**
174			* @inheritDoc
175			*/
176			public function push(...$values)
177			{
178			$this->pushAll($values);
179			}
180
181			/**
182			* @inheritDoc
183			*/
184			public function remove(int $index)
185			{
186			if (!$this->validIndex($index)) {
187			throw new OutOfRangeException();
188			}
189
190			$value = $this[$index];
191			$splice = $this->splice($index + 1, 1, null);
192			$this->clear();
193
194			$this->pushAll($splice);
195			return $value;
196			}
197
198			/**
199			* @inheritDoc
200			*/
201			public function set(int $index, $value)
202			{
203			if (!$this->validIndex($index)) {
204			throw new OutOfRangeException();
205			}
206
207			$this->sfa->offsetSet($index, $value);
208			}
209
210			/**
211			* @inheritDoc
212			*/
213			public function shift()
214			{
215			$this->emptyGuard(__METHOD__);
216			$value = $this->first();
217			unset($this[0]);
218
219			$this->checkCapacity();
220
221			return $value;
222			}
223
224			/**
225			* @inheritDoc
226			*/
227			public function toArray(): array
228			{
229			return $this->sfa->toArray();
230			}
231
232			/**
233			* @inheritDoc
234			*/
235			public function unshift(...$values)
236			{
237			$this->insert(0, ...$values);
238
239			return $this->count();
240			}
241
242			/**
243			* @inheritDoc
244			*/
245			public function unserialize($values)
246			{
247			$values = unserialize($values);
248			$this->setValues(SplFixedArray::fromArray($values));
249			}
250
251			/**
252			* @inheritDoc
253			*/
254			protected function validIndex(int $index)
255			{
256			return $index >= 0 && $index < $this->getSize();
257			}
258
259			/**
260			* @inheritDoc
261			*/
262			public function clear()
263			{
264			$this->sfa->setSize(0);
265			$this->checkCapacity();
266			}
267
268			protected function getValues(): Traversable
269			{
270			return $this->sfa;
271			}
272
273			protected function setValues(Traversable $traversable)
274			{
275			$this->clear();
276			$this->pushAll($traversable);
277			}
278
279			/**
280			* Gets the size of the array.
281			*
282			* @return int
283			*/
284			protected function getSize(): int
285			{
286			return $this->sfa->getSize();
287			}
288
289			/**
290			* Change the size of an array to the new size of size.
291			* If size is less than the current array size, any values after the
292			* new size will be discarded. If size is greater than the current
293			* array size, the array will be padded with NULL values.
294			*
295			* @param int $size The new array size. This should be a value between 0
296			* and PHP_INT_MAX.
297			* @return bool Returns TRUE on success or FALSE on failure.
298			*/
299			protected function setSize(int $size): bool
300			{
301			return $this->sfa->setSize($size);
302			}
303
304			public function __clone()
305			{
306			return $this->copy();
307			}
308
309			abstract protected function checkCapacity();
310
311			abstract protected function emptyGuard($method);
312
313			abstract public function isEmpty(): bool;
314
315			abstract public function search($value);
316
317			abstract public function splice(int $begin = 0, int $length = null, $replacement = []);
318			}
319

MBHFramework / structures

Push — 1.x ( 650a57...b30111 )

Arrayed::validIndex() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like