Code Coverage for /var/www/collections/src/Easy/Collections/CollectionArray.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total		0.00%	0 / 1		88.00%	22 / 25	CRAP		70.30%	71 / 101
CollectionArray		0.00%	0 / 1		88.00%	22 / 25	126.61		70.30%	71 / 101
__construct($array = null)					100.00%	1 / 1	3		100.00%	4 / 4
toArray()					100.00%	1 / 1	1		100.00%	1 / 1
getIterator()					100.00%	1 / 1	1		100.00%	1 / 1
getDefaultComparer()					100.00%	1 / 1	2		100.00%	4 / 4
setDefaultComparer(IComparer $defaultComparer)					100.00%	1 / 1	1		100.00%	2 / 2
count()					100.00%	1 / 1	1		100.00%	1 / 1
clear()					100.00%	1 / 1	1		100.00%	2 / 2
contains($item)					100.00%	1 / 1	1		100.00%	1 / 1
get($index)					100.00%	1 / 1	2		100.00%	3 / 3
tryGet($index, $default = null)					100.00%	1 / 1	2		100.00%	3 / 3
isEmpty()					100.00%	1 / 1	1		100.00%	1 / 1
addMultiple($items)					0.00%	0 / 1	10.37		66.67%	10 / 15
itemExists($item, $array)					0.00%	0 / 1	6.81		58.33%	7 / 12
exists(Closure $p)					100.00%	1 / 1	3		100.00%	5 / 5
filter(Closure $p)					100.00%	1 / 1	1		100.00%	1 / 1
matching(Criteria $criteria)					0.00%	0 / 1	56		0.00%	0 / 20
sort(IComparer $comparer = null)					100.00%	1 / 1	2		100.00%	5 / 5
sortByKey(IComparer $comparer = null)					100.00%	1 / 1	2		100.00%	5 / 5
remove($index)					100.00%	1 / 1	2		100.00%	4 / 4
removeValue($element)					100.00%	1 / 1	2		100.00%	5 / 5
values()					100.00%	1 / 1	1		100.00%	1 / 1
serialize()					100.00%	1 / 1	1		100.00%	1 / 1
unserialize($serialized)					100.00%	1 / 1	1		100.00%	2 / 2
__toString()					100.00%	1 / 1	1		100.00%	1 / 1
equals($obj)					100.00%	1 / 1	1		100.00%	1 / 1

1	<?php
2
3	// Copyright (c) Lellys Informática. All rights reserved. See License.txt in the project root for license information.
4
5	namespace Easy\Collections;
6
7	use ArrayIterator;
8	use Closure;
9	use Easy\Collections\Comparer\NumericKeyComparer;
10	use Easy\Collections\Generic\IComparer;
11	use Easy\Collections\Linq\Criteria;
12	use Easy\Collections\Linq\Expr\ClosureExpressionVisitor;
13	use Easy\Collections\Linq\IQueryable;
14	use Easy\Collections\Linq\ISelectable;
15	use Easy\Generics\IEquatable;
16	use InvalidArgumentException;
17	use IteratorAggregate;
18	use OutOfBoundsException;
19
20	/**
21	* Provides the abstract base class for a strongly typed collection.
22	*/
23	abstract class CollectionArray implements IEnumerable, ICollection, IQueryable, ISelectable, IEquatable
24	{
25
26	protected $array = array();
27
28	/**
29	* @var IComparer
30	*/
31	private $defaultComparer;
32
33	public function __construct($array = null)
34	{
35	if (is_array($array) \|\| $array instanceof IteratorAggregate) {
36	$this->addMultiple($array);
37	}
38	}
39
40	/**
41	* {@inheritdoc}
42	*/
43	public function toArray()
44	{
45	return $this->array;
46	}
47
48	/**
49	* {@inheritdoc}
50	*/
51	public function getIterator()
52	{
53	return new ArrayIterator($this->array);
54	}
55
56	/**
57	* Gets the default comparer for this collection
58	* @return IComparer
59	*/
60	public function getDefaultComparer()
61	{
62	if ($this->defaultComparer === null) {
63	$this->defaultComparer = new NumericKeyComparer();
64	}
65	return $this->defaultComparer;
66	}
67
68	/**
69	* Sets the default comparer for this collection
70	* @param IComparer $defaultComparer
71	* @return ArrayList
72	*/
73	public function setDefaultComparer(IComparer $defaultComparer)
74	{
75	$this->defaultComparer = $defaultComparer;
76	return $this;
77	}
78
79	/**
80	* {@inheritdoc}
81	*/
82	public function count()
83	{
84	return count($this->toArray());
85	}
86
87	/**
88	* {@inheritdoc}
89	*/
90	public function clear()
91	{
92	$this->array = array();
93	return $this;
94	}
95
96	/**
97	* {@inheritdoc}
98	*/
99	public function contains($item)
100	{
101	return $this->itemExists($item, $this->array);
102	}
103
104	/**
105	* {@inheritdoc}
106	*/
107	public function get($index)
108	{
109	if ($this->offsetExists($index) === false) {
110	throw new OutOfBoundsException('No element at position ' . $index);
111	}
112
113	return $this->array[$index];
114	}
115
116	/**
117	* {@inheritdoc}
118	*/
119	public function tryGet($index, $default = null)
120	{
121	if ($this->offsetExists($index) === false) {
122	return $default;
123	}
124
125	return $this->get($index);
126	}
127
128	/**
129	* {@inheritdoc}
130	*/
131	public function isEmpty()
132	{
133	return $this->count() < 1;
134	}
135
136	protected function addMultiple($items)
137	{
138	if (!is_array($items) && !($items instanceof IteratorAggregate)) {
139	throw new InvalidArgumentException('Items must be either a Collection or an array');
140	}
141	if ($items instanceof Enumerable) {
142	$array = array_values($items->toArray());
143	} else if (is_array($items)) {
144	$array = $items;
145	} else if ($items instanceof IteratorAggregate) {
146	foreach ($items as $k => $v) {
147	$array[$k] = $v;
148	}
149	}
150	if (empty($array) == false) {
151	$this->array = $this->array + $array;
152	}
153	}
154
155	protected function itemExists($item, $array)
156	{
157	$result = false;
158	if ($item instanceof EquatableInterface) {
159	foreach ($array as $v) {
160	if ($item->equals($v)) {
161	$result = true;
162	break;
163	}
164	}
165	} elseif (in_array($item, $array, true)) {
166	$result = in_array($item, $array);
167	} else {
168	$result = isset($array[$item]);
169	}
170	return $result;
171	}
172
173	/**
174	* {@inheritdoc}
175	*/
176	public function exists(Closure $p)
177	{
178	foreach ($this->array as $key => $element) {
179	if ($p($key, $element)) {
180	return true;
181	}
182	}
183	return false;
184	}
185
186	/**
187	* {@inheritdoc}
188	*/
189	public function filter(Closure $p)
190	{
191	return new static(array_filter($this->array, $p));
192	}
193
194	/**
195	* {@inheritdoc}
196	*/
197	public function matching(Criteria $criteria)
198	{
199	$expr = $criteria->getWhereExpression();
200	$filtered = $this->array;
201
202	if ($expr) {
203	$visitor = new ClosureExpressionVisitor();
204	$filter = $visitor->dispatch($expr);
205	$filtered = array_filter($filtered, $filter);
206	}
207
208	if ($orderings = $criteria->getOrderings()) {
209	$next = null;
210	foreach (array_reverse($orderings) as $field => $ordering) {
211	$next = ClosureExpressionVisitor::sortByField($field, $ordering == 'DESC' ? -1 : 1, $next);
212	}
213
214	usort($filtered, $next);
215	}
216
217	$offset = $criteria->getFirstResult();
218	$length = $criteria->getMaxResults();
219
220	if ($offset \|\| $length) {
221	$filtered = array_slice($filtered, (int) $offset, $length);
222	}
223
224	return new static($filtered);
225	}
226
227	/**
228	* Sorts the elements in the entire Collection<T> using the specified comparer.
229	* @param IComparer $comparer The ComparerInterface implementation to use when comparing elements, or null to use the default comparer Comparer<T>.Default.
230	*/
231	public function sort(IComparer $comparer = null)
232	{
233	if ($comparer === null) {
234	$comparer = $this->getDefaultComparer();
235	}
236	usort($this->array, array($comparer, 'compare'));
237	return $this;
238	}
239
240	/**
241	* Sorts the keys in the entire Collection<T> using the specified comparer.
242	* @param IComparer $comparer The ComparerInterface implementation to use when comparing elements, or null to use the default comparer Comparer<T>.Default.
243	*/
244	public function sortByKey(IComparer $comparer = null)
245	{
246	if ($comparer === null) {
247	$comparer = $this->getDefaultComparer();
248	}
249	uksort($this->array, array($comparer, 'compare'));
250	return $this;
251	}
252
253	/**
254	* {@inheritdoc}
255	*/
256	public function remove($index)
257	{
258	if ($this->contains($index) == false) {
259	throw new InvalidArgumentException('The key is not present in the dictionary');
260	}
261	unset($this->array[$index]);
262	return $this;
263	}
264
265	/**
266	* {@inheritdoc}
267	*/
268	public function removeValue($element)
269	{
270	$key = array_search($element, $this->array, true);
271
272	if ($key !== false) {
273	unset($this->array[$key]);
274	return true;
275	}
276
277	return false;
278	}
279
280	/**
281	* {@inheritdoc}
282	*/
283	public function values()
284	{
285	return array_values($this->array);
286	}
287
288	/**
289	* {@inheritdoc}
290	*/
291	public function serialize()
292	{
293	return serialize($this->array);
294	}
295
296	/**
297	* {@inheritdoc}
298	*/
299	public function unserialize($serialized)
300	{
301	$this->array = unserialize($serialized);
302	return $this->array;
303	}
304
305	/**
306	* {@inheritdoc}
307	*/
308	public function __toString()
309	{
310	return get_class($this);
311	}
312
313	public function equals($obj)
314	{
315	return ($obj === $this);
316	}
317
318	}