ArrayList::remove() - Code Metrics - Inspection of "Fixed error in doubly linked list with indexOf" - SiroDiaz/DataStructures - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2cb83b...930afd )

by Siro Díaz

created 2017-07-12 16:30 UTC

ArrayList::remove() A

↳ Parent: ArrayList

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	1

<?php
/**
 * DataStructures for PHP
 *
 * @link      https://github.com/SiroDiaz/DataStructures
 * @copyright Copyright (c) 2017 Siro Díaz Palazón
 * @license   https://github.com/SiroDiaz/DataStructures/blob/master/README.md (MIT License)
 */
namespace DataStructures\Lists;

use DataStructures\Lists\Interfaces\ListInterface;
use DataStructures\Lists\Traits\{CountTrait, ArrayAccessTrait};
use OutOfBoundsException;

/**
 * ArrayList
 *
 * This class is an implementation of a list based in native arrays.
 * The access time is, in general, O(1) since all in PHP is a hash table.
 *
 * @author Siro Diaz Palazon <[email protected]>
 */
class ArrayList implements ListInterface {
    use CountTrait;
    use ArrayAccessTrait;

    private $data;
    private $current;
    private $position;
    private $size;

    public function __construct() {
        $this->data = [];
        $this->size = 0;
        $this->position = 0;
    }

    /**
     * Add a new node in the specified index.
     *
     * @param integer $index the position.
     * @param mixed $data the data to be stored.
     */
    public function insert($index, $data) {
        array_splice($this->data, $index, 0, $data);
        $this->size++;
    }
    
    /**
     * Removes all the array items.
     */
    public function clear() {
        $this->data = [];
        $this->size = 0;
    }
    
     /**
     * Returns the array in the especified index.
     *
     * @param integer $index Index that must be greater than 0
     *  and lower than the list size.
     * @return mixed The data stored in the given index
     * @throws OutOfBoundsException if index is out bounds.
     */
    public function get($index) {
        if($index < 0 || $index > $this->size - 1) {
            throw new OutOfBoundsException();
        }

        return $this->data[$index];
    }

    /**
     * Returns the last node with O(1).
     *
     * @return mixed null if the array is empty.
     */
    public function getLast() {
        if(!$this->empty()) {
            return $this->data[$this->size - 1];
        }
        
        return null;
    }

    public function getAll() {
        foreach($this->data as $data) {
            yield $data;
        }
    }
    
    /**
     * Removes and returns the last item in the array.
     *
     * @return mixed data in node.
     */
    public function pop() {
        return $this->delete(($this->size === 0) ? 0 : $this->size - 1);
    }

    /**
     * Adds at the end of the list new node containing
     * the data to be stored.
     *
     * @param mixed $data The data
     */
    public function push($data) {
        $this->data[] = $data;
        $this->size++;
    }

    /**
     *
     */
    public function contains($data) : bool {
        return in_array($data, $this->data);
    }

    /**
     *
     */
    public function indexOf($data) {
        return array_search($data, $this->data, true);
    }

    /**
     *
     */
    public function lastIndexOf($data) {
        for($i = $this->size - 1; $i >= 0; $i--) {
            if($this->data[$i] === $data) {
                return $i;
            }
        }

        return false;
    }

    /**
     *
     */
    public function remove($data) {
        $i = 0;
        
        while($i < $this->size) {
            $i++;
        }

        return null;
    }

    /**
     * Adds at the beginning a node in the list.
     *
     * @param mixed $data
     * @return mixed the data stored.
     */
    public function unshift($data) {
        $this->insert(0, $data);
    }

    /**
     * Delete a node in the given position and returns it back.
     *
     * @param integer $index the position.
     * @throws OutOfBoundsException if index is negative
     *  or is greater than the size of the list.
     */
    public function delete($index) {
        if($this->size === 0 || $index < 0 || $index > $this->size - 1) {
            throw new OutOfBoundsException();
        }
        
        $data = $this->data[$index];
        array_splice($this->data, $index, 1);
        $this->size--;

        return $data;
    }
    
    /**
     * Deletes the first node of the list and returns it.
     *
     * @return mixed the data.
     */
    public function shift() {
        return $this->delete(0);
    }

    /**
     * Returns array stored in the data attribute.
     *
     * @return array data stored in all nodes.
     */
    public function toArray() : array {
        return $this->data;
    }

    /**
     * Reset the cursor position.
     */
    public function rewind() {
        $this->position = 0;
        $this->current = $this->data[$this->position];
    }

    /**
     * Returns the current node data.
     *
     * @return mixed
     */
    public function current() {
        return $this->current;
    }

    /**
     * Key or index that indicates the cursor position.
     *
     * @return integer The current position.
     */
    public function key() {
        return $this->position;
    }

    /**
     * Move the cursor to the next node and increments the
     * position counter.
     */
    public function next() {
        ++$this->position;
        $this->current = $this->data[$this->position];
    }

    /**
     * Returns if the current pointer position is valid.
     *
     * @return boolean true if pointer is not last, else false.
     */
    public function valid() {
        return $this->position < $this->size;
    }

    /**
     * Binds to count() method. This is equal to make $this->tree->size().
     *
     * @return integer the tree size. 0 if it is empty.
     */
    public function count() {
        return $this->size;
    }

    /**
     * Returns the array size.
     *
     * @return int the length
     */
    public function size() : int {
        return $this->size;
    }

    /**
     * Checks if the list is empty.
     *
     * @return boolean true if is empty, else false.
     */
    public function empty() : bool {
        return $this->size === 0;
    }
}

1			<?php
2			/**
3			* DataStructures for PHP
4			*
5			* @link https://github.com/SiroDiaz/DataStructures
6			* @copyright Copyright (c) 2017 Siro Díaz Palazón
7			* @license https://github.com/SiroDiaz/DataStructures/blob/master/README.md (MIT License)
8			*/
9			namespace DataStructures\Lists;
10
11			use DataStructures\Lists\Interfaces\ListInterface;
12			use DataStructures\Lists\Traits\{CountTrait, ArrayAccessTrait};
13			use OutOfBoundsException;
14
15			/**
16			* ArrayList
17			*
18			* This class is an implementation of a list based in native arrays.
19			* The access time is, in general, O(1) since all in PHP is a hash table.
20			*
21			* @author Siro Diaz Palazon <[email protected]>
22			*/
23			class ArrayList implements ListInterface {
24			use CountTrait;
25			use ArrayAccessTrait;
26
27			private $data;
28			private $current;
29			private $position;
30			private $size;
31
32			public function __construct() {
33			$this->data = [];
34			$this->size = 0;
35			$this->position = 0;
36			}
37
38			/**
39			* Add a new node in the specified index.
40			*
41			* @param integer $index the position.
42			* @param mixed $data the data to be stored.
43			*/
44			public function insert($index, $data) {
45			array_splice($this->data, $index, 0, $data);
46			$this->size++;
47			}
48
49			/**
50			* Removes all the array items.
51			*/
52			public function clear() {
53			$this->data = [];
54			$this->size = 0;
55			}
56
57			/**
58			* Returns the array in the especified index.
59			*
60			* @param integer $index Index that must be greater than 0
61			* and lower than the list size.
62			* @return mixed The data stored in the given index
63			* @throws OutOfBoundsException if index is out bounds.
64			*/
65			public function get($index) {
66			if($index < 0 \|\| $index > $this->size - 1) {
67			throw new OutOfBoundsException();
68			}
69
70			return $this->data[$index];
71			}
72
73			/**
74			* Returns the last node with O(1).
75			*
76			* @return mixed null if the array is empty.
77			*/
78			public function getLast() {
79			if(!$this->empty()) {
80			return $this->data[$this->size - 1];
81			}
82
83			return null;
84			}
85
86			public function getAll() {
87			foreach($this->data as $data) {
88			yield $data;
89			}
90			}
91
92			/**
93			* Removes and returns the last item in the array.
94			*
95			* @return mixed data in node.
96			*/
97			public function pop() {
98			return $this->delete(($this->size === 0) ? 0 : $this->size - 1);
99			}
100
101			/**
102			* Adds at the end of the list new node containing
103			* the data to be stored.
104			*
105			* @param mixed $data The data
106			*/
107			public function push($data) {
108			$this->data[] = $data;
109			$this->size++;
110			}
111
112			/**
113			*
114			*/
115			public function contains($data) : bool {
116			return in_array($data, $this->data);
117			}
118
119			/**
120			*
121			*/
122			public function indexOf($data) {
123			return array_search($data, $this->data, true);
124			}
125
126			/**
127			*
128			*/
129			public function lastIndexOf($data) {
130			for($i = $this->size - 1; $i >= 0; $i--) {
131			if($this->data[$i] === $data) {
132			return $i;
133			}
134			}
135
136			return false;
137			}
138
139			/**
140			*
141			*/
142			public function remove($data) {
143			$i = 0;
144
145			while($i < $this->size) {
146			$i++;
147			}
148
149			return null;
150			}
151
152			/**
153			* Adds at the beginning a node in the list.
154			*
155			* @param mixed $data
156			* @return mixed the data stored.
157			*/
158			public function unshift($data) {
159			$this->insert(0, $data);
160			}
161
162			/**
163			* Delete a node in the given position and returns it back.
164			*
165			* @param integer $index the position.
166			* @throws OutOfBoundsException if index is negative
167			* or is greater than the size of the list.
168			*/
169			public function delete($index) {
170			if($this->size === 0 \|\| $index < 0 \|\| $index > $this->size - 1) {
171			throw new OutOfBoundsException();
172			}
173
174			$data = $this->data[$index];
175			array_splice($this->data, $index, 1);
176			$this->size--;
177
178			return $data;
179			}
180
181			/**
182			* Deletes the first node of the list and returns it.
183			*
184			* @return mixed the data.
185			*/
186			public function shift() {
187			return $this->delete(0);
188			}
189
190			/**
191			* Returns array stored in the data attribute.
192			*
193			* @return array data stored in all nodes.
194			*/
195			public function toArray() : array {
196			return $this->data;
197			}
198
199			/**
200			* Reset the cursor position.
201			*/
202			public function rewind() {
203			$this->position = 0;
204			$this->current = $this->data[$this->position];
205			}
206
207			/**
208			* Returns the current node data.
209			*
210			* @return mixed
211			*/
212			public function current() {
213			return $this->current;
214			}
215
216			/**
217			* Key or index that indicates the cursor position.
218			*
219			* @return integer The current position.
220			*/
221			public function key() {
222			return $this->position;
223			}
224
225			/**
226			* Move the cursor to the next node and increments the
227			* position counter.
228			*/
229			public function next() {
230			++$this->position;
231			$this->current = $this->data[$this->position];
232			}
233
234			/**
235			* Returns if the current pointer position is valid.
236			*
237			* @return boolean true if pointer is not last, else false.
238			*/
239			public function valid() {
240			return $this->position < $this->size;
241			}
242
243			/**
244			* Binds to count() method. This is equal to make $this->tree->size().
245			*
246			* @return integer the tree size. 0 if it is empty.
247			*/
248			public function count() {
249			return $this->size;
250			}
251
252			/**
253			* Returns the array size.
254			*
255			* @return int the length
256			*/
257			public function size() : int {
258			return $this->size;
259			}
260
261			/**
262			* Checks if the list is empty.
263			*
264			* @return boolean true if is empty, else false.
265			*/
266			public function empty() : bool {
267			return $this->size === 0;
268			}
269			}

SiroDiaz / DataStructures

Push — master ( 2cb83b...930afd )

ArrayList::remove() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like