AbstractCollection::contains() - Code Metrics - Inspection of "Clone collection of objects" - phootwork/collection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4)

by Cristiano

created 2018-10-25 18:10 UTC

AbstractCollection::contains() A

↳ Parent: AbstractCollection

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php
namespace phootwork\collection;

use phootwork\lang\Comparator;

/**
 * AbstractCollection providing implemention for the Collection interface.
 *
 * @author Thomas Gossmann
 */
abstract class AbstractCollection implements Collection {

	protected $collection = [];

	public function contains($element) {
		return in_array($element, $this->collection, true);
	}

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

	public function isEmpty() {
		return count($this->collection) == 0;
	}

	public function clear() {
		$this->collection = [];
	}

	public function toArray() {
		return $this->collection;
	}

	/**
	 * Applies the callback to the elements
	 *
	 * @param callable $callback the applied callback function
	 * @return static
	 */
	public function map(callable $callback) {
		return new static(array_map($callback, $this->collection));
	}

	/**
	 * Filters elements using a callback function
	 *
	 * @param callable $callback the filter function
	 * @return static
	 */
	public function filter(callable $callback) {
		return new static(array_filter($this->collection, $callback));
	}

	/**
	 * Tests whether all elements in the collection pass the test implemented by the provided function.
	 *
	 * Returns <code>true</code> for an empty collection.
	 *
	 * @param callable $callback
	 * @return boolean
	 */
	public function every(callable $callback) {
		$match = true;
		foreach ($this->collection as $element) {
			$match = $match && $callback($element);
		}

		return $match;
	}

	/**
	 * Tests whether at least one element in the collection passes the test implemented by the provided function.
	 *
	 * Returns <code>false</code> for an empty collection.
	 *
	 * @param callable $callback
	 * @return boolean
	 */
	public function some(callable $callback) {
		$match = false;
		foreach ($this->collection as $element) {
			$match = $match || $callback($element);
		}

		return $match;
	}

	/**
	 * Searches the collection for query using the callback function on each element
	 *
	 * The callback function takes one or two parameters:
	 *
	 *     function ($element [, $query]) {}
	 *
	 * The callback must return a boolean
	 *
	 * @param mixed $query (optional)
	 * @param callable $callback
	 * @return boolean
	 */
	public function search() {
		if (func_num_args() == 1) {
			$callback = func_get_arg(0);
		} else {
			$query = func_get_arg(0);
			$callback = func_get_arg(1);
		}

		foreach ($this->collection as $element) {
			$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);

			if ($return) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Searches the collection with a given callback and returns the first element if found.
	 *
	 * The callback function takes one or two parameters:
	 *
	 *     function ($element [, $query]) {}
	 *
	 * The callback must return a boolean
	 *
	 * @param mixed $query OPTIONAL the provided query
	 * @param callable $callback the callback function
	 * @return mixed|null the found element or null if it hasn't been found
	 */
	public function find() {
		if (func_num_args() == 1) {
			$callback = func_get_arg(0);
		} else {
			$query = func_get_arg(0);
			$callback = func_get_arg(1);
		}

		foreach ($this->collection as $element) {
			$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);

			if ($return) {
				return $element;
			}
		}

		return null;
	}

	/**
	 * Searches the collection with a given callback and returns the last element if found.
	 *
	 * The callback function takes one or two parameters:
	 *
	 *     function ($element [, $query]) {}
	 *
	 * The callback must return a boolean
	 *
	 * @param mixed $query OPTIONAL the provided query
	 * @param callable $callback the callback function
	 * @return mixed|null the found element or null if it hasn't been found
	 */
	public function findLast() {
		if (func_num_args() == 1) {
			$callback = func_get_arg(0);
		} else {
			$query = func_get_arg(0);
			$callback = func_get_arg(1);
		}

		$reverse = array_reverse($this->collection, true);
		foreach ($reverse as $element) {
			$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);

			if ($return) {
				return $element;
			}
		}

		return null;
	}

	/**
	 * Searches the collection with a given callback and returns all matching elements.
	 *
	 * The callback function takes one or two parameters:
	 *
	 *     function ($element [, $query]) {}
	 *
	 * The callback must return a boolean
	 *
	 * @param mixed $query OPTIONAL the provided query
	 * @param callable $callback the callback function
	 * @return mixed|null the found element or null if it hasn't been found
	 */
	public function findAll() {
		if (func_num_args() == 1) {
			$callback = func_get_arg(0);
		} else {
			$query = func_get_arg(0);
			$callback = func_get_arg(1);
		}

		$collection = [];
		foreach ($this->collection as $k => $element) {
			$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);

			if ($return) {
				$collection[$k] = $element;
			}
		}

		return new static($collection);
	}

	/**
	 * Internal sort function
	 *
	 * @param array $collection the collection on which is operated on
	 * @param Comparator|callable|null $cmp the compare function
	 * @param callable $usort the sort function for user passed $cmd
	 * @param callable $sort the default sort function
	 */
	protected function doSort(&$collection, $cmp, callable $usort, callable $sort) {
		if (is_callable($cmp)) {
			$usort($collection, $cmp);
		} else if ($cmp instanceof Comparator) {
			$usort($collection, function($a, $b) use ($cmp) {
				return $cmp->compare($a, $b);
			});
		} else {
			$sort($collection);
		}
	}

	/**
	 * @internal
	 */
	public function rewind() {
		return reset($this->collection);
	}

	/**
	 * @internal
	 */
	public function current() {
		return current($this->collection);
	}

	/**
	 * @internal
	 */
	public function key() {
		return key($this->collection);
	}

	/**
	 * @internal
	 */
	public function next() {
		return next($this->collection);
	}

	/**
	 * @internal
	 */
	public function valid() {
		return key($this->collection) !== null;
	}

	/**
	 * @internal
	 */
	public function __clone() {
		$clonedCollection = [];
		foreach ($this->collection as $key => $element) {
			if (is_object($element)) {
				$clonedCollection[$key] = clone $element;
				continue;
			}
			$clonedCollection[$key] = $element;
		}
		$this->collection = $clonedCollection;
	}

}

1		<?php
2		namespace phootwork\collection;
3
4		use phootwork\lang\Comparator;
5
6		/**
7		* AbstractCollection providing implemention for the Collection interface.
8		*
9		* @author Thomas Gossmann
10		*/
11		abstract class AbstractCollection implements Collection {
12
13		protected $collection = [];
14
15	5	public function contains($element) {
16	5	return in_array($element, $this->collection, true);
17		}
18
19	43	public function size() {
20	43	return count($this->collection);
21		}
22
23	1	public function isEmpty() {
24	1	return count($this->collection) == 0;
25		}
26
27	4	public function clear() {
28	4	$this->collection = [];
29	4	}
30
31	25	public function toArray() {
32	25	return $this->collection;
33		}
34
35		/**
36		* Applies the callback to the elements
37		*
38		* @param callable $callback the applied callback function
39		* @return static
40		*/
41	9	public function map(callable $callback) {
42	9	return new static(array_map($callback, $this->collection));
43		}
44
45		/**
46		* Filters elements using a callback function
47		*
48		* @param callable $callback the filter function
49		* @return static
50		*/
51	3	public function filter(callable $callback) {
52	3	return new static(array_filter($this->collection, $callback));
53		}
54
55		/**
56		* Tests whether all elements in the collection pass the test implemented by the provided function.
57		*
58		* Returns <code>true</code> for an empty collection.
59		*
60		* @param callable $callback
61		* @return boolean
62		*/
63	1	public function every(callable $callback) {
64	1	$match = true;
65	1	foreach ($this->collection as $element) {
66	1	$match = $match && $callback($element);
67		}
68
69	1	return $match;
70		}
71
72		/**
73		* Tests whether at least one element in the collection passes the test implemented by the provided function.
74		*
75		* Returns <code>false</code> for an empty collection.
76		*
77		* @param callable $callback
78		* @return boolean
79		*/
80	1	public function some(callable $callback) {
81	1	$match = false;
82	1	foreach ($this->collection as $element) {
83	1	$match = $match \|\| $callback($element);
84		}
85
86	1	return $match;
87		}
88
89		/**
90		* Searches the collection for query using the callback function on each element
91		*
92		* The callback function takes one or two parameters:
93		*
94		* function ($element [, $query]) {}
95		*
96		* The callback must return a boolean
97		*
98		* @param mixed $query (optional)
99		* @param callable $callback
100		* @return boolean
101		*/
102	1	public function search() {
103	1	if (func_num_args() == 1) {
104	1	$callback = func_get_arg(0);
105		} else {
106	1	$query = func_get_arg(0);
107	1	$callback = func_get_arg(1);
108		}
109
110	1	foreach ($this->collection as $element) {
111	1	$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);
112
113	1	if ($return) {
114	1	return true;
115		}
116		}
117	1	return false;
118		}
119
120		/**
121		* Searches the collection with a given callback and returns the first element if found.
122		*
123		* The callback function takes one or two parameters:
124		*
125		* function ($element [, $query]) {}
126		*
127		* The callback must return a boolean
128		*
129		* @param mixed $query OPTIONAL the provided query
130		* @param callable $callback the callback function
131		* @return mixed\|null the found element or null if it hasn't been found
132		*/
133	3	public function find() {
134	3	if (func_num_args() == 1) {
135	2	$callback = func_get_arg(0);
136		} else {
137	3	$query = func_get_arg(0);
138	3	$callback = func_get_arg(1);
139		}
140
141	3	foreach ($this->collection as $element) {
142	3	$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);
143
144	3	if ($return) {
145	3	return $element;
146		}
147		}
148
149	1	return null;
150		}
151
152		/**
153		* Searches the collection with a given callback and returns the last element if found.
154		*
155		* The callback function takes one or two parameters:
156		*
157		* function ($element [, $query]) {}
158		*
159		* The callback must return a boolean
160		*
161		* @param mixed $query OPTIONAL the provided query
162		* @param callable $callback the callback function
163		* @return mixed\|null the found element or null if it hasn't been found
164		*/
165	2	public function findLast() {
166	2	if (func_num_args() == 1) {
167	2	$callback = func_get_arg(0);
168		} else {
169	2	$query = func_get_arg(0);
170	2	$callback = func_get_arg(1);
171		}
172
173	2	$reverse = array_reverse($this->collection, true);
174	2	foreach ($reverse as $element) {
175	2	$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);
176
177	2	if ($return) {
178	2	return $element;
179		}
180		}
181
182	1	return null;
183		}
184
185		/**
186		* Searches the collection with a given callback and returns all matching elements.
187		*
188		* The callback function takes one or two parameters:
189		*
190		* function ($element [, $query]) {}
191		*
192		* The callback must return a boolean
193		*
194		* @param mixed $query OPTIONAL the provided query
195		* @param callable $callback the callback function
196		* @return mixed\|null the found element or null if it hasn't been found
197		*/
198	1	public function findAll() {
199	1	if (func_num_args() == 1) {
200	1	$callback = func_get_arg(0);
201		} else {
202	1	$query = func_get_arg(0);
203	1	$callback = func_get_arg(1);
204		}
205
206	1	$collection = [];
207	1	foreach ($this->collection as $k => $element) {
208	1	$return = func_num_args() == 1 ? $callback($element) : $callback($element, $query);
209
210	1	if ($return) {
211	1	$collection[$k] = $element;
212		}
213		}
214
215	1	return new static($collection);
216		}
217
218		/**
219		* Internal sort function
220		*
221		* @param array $collection the collection on which is operated on
222		* @param Comparator\|callable\|null $cmp the compare function
223		* @param callable $usort the sort function for user passed $cmd
224		* @param callable $sort the default sort function
225		*/
226	3	protected function doSort(&$collection, $cmp, callable $usort, callable $sort) {
227	3	if (is_callable($cmp)) {
228	3	$usort($collection, $cmp);
229	3	} else if ($cmp instanceof Comparator) {
230	3	$usort($collection, function($a, $b) use ($cmp) {
231	3	return $cmp->compare($a, $b);
232	3	});
233		} else {
234	3	$sort($collection);
235		}
236	3	}
237
238		/**
239		* @internal
240		*/
241	5	public function rewind() {
242	5	return reset($this->collection);
243		}
244
245		/**
246		* @internal
247		*/
248	5	public function current() {
249	5	return current($this->collection);
250		}
251
252		/**
253		* @internal
254		*/
255	1	public function key() {
256	1	return key($this->collection);
257		}
258
259		/**
260		* @internal
261		*/
262	5	public function next() {
263	5	return next($this->collection);
264		}
265
266		/**
267		* @internal
268		*/
269	5	public function valid() {
270	5	return key($this->collection) !== null;
271		}
272
273		/**
274		* @internal
275		*/
276	8	public function __clone() {
277	8	$clonedCollection = [];
278	8	foreach ($this->collection as $key => $element) {
279	8	if (is_object($element)) {
280	3	$clonedCollection[$key] = clone $element;
281	3	continue;
282		}
283	5	$clonedCollection[$key] = $element;
284		}
285	8	$this->collection = $clonedCollection;
286	8	}
287
288		}

phootwork / collection

Pull Request — master (#4)

AbstractCollection::contains() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like