Collection::__construct() - Code Metrics - niden/cardoe - Measure and Improve Code Quality continuously with Scrutinizer

Collection::__construct() A
last analyzed 2020-03-02 03:47 UTC

↳ Parent: Collection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1.0156

Importance

Changes

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

<?php

/**
 * This file is part of the Phalcon Framework.
 *
 * (c) Phalcon Team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Phalcon;

use ArrayAccess;
use Countable;
use Generator;
use IteratorAggregate;
use JsonSerializable;
use Phalcon\Helper\Json;
use Serializable;

use function array_key_exists;
use function array_keys;
use function array_values;
use function is_object;
use function mb_strtolower;
use function method_exists;
use function serialize;
use function settype;
use function strtolower;
use function unserialize;

/**
 * `Phalcon\Collection` is a supercharged object oriented array. It implements:
 * - [ArrayAccess](https://www.php.net/manual/en/class.arrayaccess.php)
 * - [Countable](https://www.php.net/manual/en/class.countable.php)
 * -
 * [IteratorAggregate](https://www.php.net/manual/en/class.iteratoraggregate.php)
 * -
 * [JsonSerializable](https://www.php.net/manual/en/class.jsonserializable.php)
 * - [Serializable](https://www.php.net/manual/en/class.serializable.php)
 *
 * It can be used in any part of the application that needs collection of data
 * Such implementations are for instance accessing globals `$_GET`, `$_POST`
 * etc.
 *
 * @property array $data
 * @property bool  $insensitive
 * @property array $lowerKeys
 */
class Collection implements
    ArrayAccess,
    Countable,
    IteratorAggregate,
    JsonSerializable,
    Serializable
{
    /**
     * @var array
     */
    protected $data = [];

    /**
     * @var bool
     */
    protected $insensitive = true;

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

    /**
     * Collection constructor.
     *
     * @param array $data
     * @param bool  $insensitive
     */
    public function __construct(array $data = [], bool $insensitive = true)
    {
        $this->insensitive = $insensitive;
        $this->init($data);
    }

    /**
     * Magic getter to get an element from the collection
     *
     * @param string $element
     *
     * @return mixed|null
     */
    public function __get(string $element)
    {
        return $this->get($element);
    }

    /**
     * Magic isset to check whether an element exists or not
     *
     * @param string $element
     *
     * @return bool
     */
    public function __isset(string $element): bool
    {
        return $this->has($element);
    }

    /**
     * Magic setter to assign values to an element
     *
     * @param string $element
     * @param mixed  $value
     */
    public function __set(string $element, $value): void
    {
        $this->set($element, $value);
    }

    /**
     * Magic unset to remove an element from the collection
     *
     * @param string $element
     */
    public function __unset(string $element): void
    {
        $this->remove($element);
    }

    /**
     * Clears the internal collection
     */
    public function clear(): void
    {
        $this->data      = [];
        $this->lowerKeys = [];
    }

    /**
     * Count elements of an object.
     *
     * @return int
     */
    public function count(): int
    {
        return count($this->data);
    }

    /**
     * Get the element from the collection
     *
     * @param string      $element
     * @param mixed|null  $defaultValue
     * @param string|null $cast
     *
     * @return mixed
     */
    public function get(
        string $element,
        $defaultValue = null,
        string $cast = null
    ) {
        $element = ($this->insensitive) ? strtolower($element) : $element;

        if (!array_key_exists($element, $this->lowerKeys)) {
            return $defaultValue;
        }

        $key   = $this->lowerKeys[$element];
        $value = $this->data[$key];

        if (null !== $cast) {
            settype($value, $cast);
        }

        return $value;
    }

    /**
     * Returns the generator of the class
     *
     * @return Generator
     */
    public function getIterator(): Generator
    {
        foreach ($this->data as $key => $value) {
            yield $key => $value;
        }
    }

    /**
     * Returns the keys (insensitive or not) of the collection
     *
     * @param bool $insensitive
     *
     * @return array
     */
    public function getKeys(bool $insensitive = true): array
    {
        if ($insensitive) {
            return array_keys($this->lowerKeys);
        } else {
            return array_keys($this->data);
        }
    }

    /**
     * Returns the values of the internal array
     *
     * @return array
     */
    public function getValues(): array
    {
        return array_values($this->data);
    }

    /**
     * Get the element from the collection
     *
     * @param string $element
     *
     * @return bool
     */
    public function has(string $element): bool
    {
        if ($this->insensitive) {
            $element = strtolower($element);
        }

        return isset($this->lowerKeys[$element]);
    }

    /**
     * Initialize internal array
     *
     * @param array $data
     */
    public function init(array $data = []): void
    {
        foreach ($data as $key => $value) {
            $this->setData($key, $value);
        }
    }

    /**
     * Specify data which should be serialized to JSON
     *
     * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
     */
    public function jsonSerialize(): array
    {
        $records = [];

        foreach ($this->data as $key => $value) {
            if (is_object($value) && method_exists($value, "jsonSerialize")) {
                $records[$key] = $value->jsonSerialize();
            } else {
                $records[$key] = $value;
            }
        }

        return $records;
    }

    /**
     * Whether a offset exists
     *
     * @link https://php.net/manual/en/arrayaccess.offsetexists.php
     *
     * @param mixed $element
     *
     * @return bool
     */
    public function offsetExists($element): bool
    {
        $element = (string) $element;

        return $this->has($element);
    }

    /**
     * Offset to retrieve
     *
     * @link https://php.net/manual/en/arrayaccess.offsetget.php
     *
     * @param mixed $element
     *
     * @return mixed
     */
    public function offsetGet($element)
    {
        $element = (string) $element;

        return $this->get($element);
    }

    /**
     * Offset to set
     *
     * @link https://php.net/manual/en/arrayaccess.offsetset.php
     *
     * @param mixed $element
     * @param mixed $value
     */
    public function offsetSet($element, $value): void
    {
        $element = (string) $element;

        $this->set($element, $value);
    }

    /**
     * Offset to unset
     *
     * @link https://php.net/manual/en/arrayaccess.offsetunset.php
     *
     * @param mixed $element
     */
    public function offsetUnset($element): void
    {
        $element = (string) $element;

        $this->remove($element);
    }

    /**
     * Delete the element from the collection
     *
     * @param string $element
     */
    public function remove(string $element): void
    {
        if ($this->has($element)) {
            if ($this->insensitive) {
                $element = strtolower($element);
            }

            $value = $this->lowerKeys[$element];

            unset($this->lowerKeys[$element]);
            unset($this->data[$value]);
        }
    }

    /**
     * Set an element in the collection
     *
     * @param string $element
     * @param mixed  $value
     */
    public function set(string $element, $value): void
    {
        $this->setData($element, $value);
    }

    /**
     * String representation of object
     *
     * @link https://php.net/manual/en/serializable.serialize.php
     */
    public function serialize(): string
    {
        return serialize($this->toArray());
    }

    /**
     * Returns the object in an array format
     */
    public function toArray(): array
    {
        return $this->data;
    }

    /**
     * Returns the object in a JSON format
     *
     * The default string uses the following options for json_encode
     *
     * JSON_HEX_TAG, JSON_HEX_APOS, JSON_HEX_AMP, JSON_HEX_QUOT,
     * JSON_UNESCAPED_SLASHES
     *
     * @see https://www.ietf.org/rfc/rfc4627.txt
     *
     * @param int $options
     *
     * @return string
     */
    public function toJson(int $options = 79): string
    {
        return Json::encode($this->jsonSerialize(), $options);
    }

    /**
     * Constructs the object
     *
     * @link https://php.net/manual/en/serializable.unserialize.php
     *
     * @param string $serialized
     */
    public function unserialize($serialized): void
    {
        $serialized = (string) $serialized;
        $data       = unserialize($serialized);

        $this->init($data);
    }

    /**
     * Internal method to set data
     *
     * @param mixed $element
     * @param mixed $value
     */
    protected function setData($element, $value): void
    {
        $element = (string) $element;
        $key     = ($this->insensitive) ? mb_strtolower($element) : $element;

        $this->data[$element]  = $value;
        $this->lowerKeys[$key] = $element;
    }
}


1		<?php
2
3		/**
4		* This file is part of the Phalcon Framework.
5		*
6		* (c) Phalcon Team <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE.txt
9		* file that was distributed with this source code.
10		*/
11
12		declare(strict_types=1);
13
14		namespace Phalcon;
15
16		use ArrayAccess;
17		use Countable;
18		use Generator;
19		use IteratorAggregate;
20		use JsonSerializable;
21		use Phalcon\Helper\Json;
22		use Serializable;
23
24		use function array_key_exists;
25		use function array_keys;
26		use function array_values;
27		use function is_object;
28		use function mb_strtolower;
29		use function method_exists;
30		use function serialize;
31		use function settype;
32		use function strtolower;
33		use function unserialize;
34
35		/**
36		* `Phalcon\Collection` is a supercharged object oriented array. It implements:
37		* - [ArrayAccess](https://www.php.net/manual/en/class.arrayaccess.php)
38		* - [Countable](https://www.php.net/manual/en/class.countable.php)
39		* -
40		* [IteratorAggregate](https://www.php.net/manual/en/class.iteratoraggregate.php)
41		* -
42		* [JsonSerializable](https://www.php.net/manual/en/class.jsonserializable.php)
43		* - [Serializable](https://www.php.net/manual/en/class.serializable.php)
44		*
45		* It can be used in any part of the application that needs collection of data
46		* Such implementations are for instance accessing globals `$_GET`, `$_POST`
47		* etc.
48		*
49		* @property array $data
50		* @property bool $insensitive
51		* @property array $lowerKeys
52		*/
53		class Collection implements
54		ArrayAccess,
55		Countable,
56		IteratorAggregate,
57		JsonSerializable,
58		Serializable
59		{
60		/**
61		* @var array
62		*/
63		protected $data = [];
64
65		/**
66		* @var bool
67		*/
68		protected $insensitive = true;
69
70		/**
71		* @var array
72		*/
73		protected $lowerKeys = [];
74
75		/**
76		* Collection constructor.
77		*
78		* @param array $data
79		* @param bool $insensitive
80		*/
81	391	public function __construct(array $data = [], bool $insensitive = true)
82		{
83	391	$this->insensitive = $insensitive;
84	391	$this->init($data);
85	391	}
86
87		/**
88		* Magic getter to get an element from the collection
89		*
90		* @param string $element
91		*
92		* @return mixed\|null
93		*/
94	15	public function __get(string $element)
95		{
96	15	return $this->get($element);
97		}
98
99		/**
100		* Magic isset to check whether an element exists or not
101		*
102		* @param string $element
103		*
104		* @return bool
105		*/
106	11	public function __isset(string $element): bool
107		{
108	11	return $this->has($element);
109		}
110
111		/**
112		* Magic setter to assign values to an element
113		*
114		* @param string $element
115		* @param mixed $value
116		*/
117	2	public function __set(string $element, $value): void
118		{
119	2	$this->set($element, $value);
120	1	}
121
122		/**
123		* Magic unset to remove an element from the collection
124		*
125		* @param string $element
126		*/
127	2	public function __unset(string $element): void
128		{
129	2	$this->remove($element);
130	1	}
131
132		/**
133		* Clears the internal collection
134		*/
135	38	public function clear(): void
136		{
137	38	$this->data = [];
138	38	$this->lowerKeys = [];
139	38	}
140
141		/**
142		* Count elements of an object.
143		*
144		* @return int
145		*/
146	21	public function count(): int
147		{
148	21	return count($this->data);
149		}
150
151		/**
152		* Get the element from the collection
153		*
154		* @param string $element
155		* @param mixed\|null $defaultValue
156		* @param string\|null $cast
157		*
158		* @return mixed
159		*/
160	119	public function get(
161		string $element,
162		$defaultValue = null,
163		string $cast = null
164		) {
165	119	$element = ($this->insensitive) ? strtolower($element) : $element;
166
167	119	if (!array_key_exists($element, $this->lowerKeys)) {
168	34	return $defaultValue;
169		}
170
171	104	$key = $this->lowerKeys[$element];
172	104	$value = $this->data[$key];
173
174	104	if (null !== $cast) {
175	10	settype($value, $cast);
176		}
177
178	104	return $value;
179		}
180
181		/**
182		* Returns the generator of the class
183		*
184		* @return Generator
185		*/
186	14	public function getIterator(): Generator
187		{
188	14	foreach ($this->data as $key => $value) {
189	11	yield $key => $value;
190		}
191	14	}
192
193		/**
194		* Returns the keys (insensitive or not) of the collection
195		*
196		* @param bool $insensitive
197		*
198		* @return array
199		*/
200	5	public function getKeys(bool $insensitive = true): array
201		{
202	5	if ($insensitive) {
203	5	return array_keys($this->lowerKeys);
204		} else {
205	1	return array_keys($this->data);
206		}
207		}
208
209		/**
210		* Returns the values of the internal array
211		*
212		* @return array
213		*/
214	1	public function getValues(): array
215		{
216	1	return array_values($this->data);
217		}
218
219		/**
220		* Get the element from the collection
221		*
222		* @param string $element
223		*
224		* @return bool
225		*/
226	209	public function has(string $element): bool
227		{
228	209	if ($this->insensitive) {
229	207	$element = strtolower($element);
230		}
231
232	209	return isset($this->lowerKeys[$element]);
233		}
234
235		/**
236		* Initialize internal array
237		*
238		* @param array $data
239		*/
240	391	public function init(array $data = []): void
241		{
242	391	foreach ($data as $key => $value) {
243	201	$this->setData($key, $value);
244		}
245	391	}
246
247		/**
248		* Specify data which should be serialized to JSON
249		*
250		* @link https://php.net/manual/en/jsonserializable.jsonserialize.php
251		*/
252	8	public function jsonSerialize(): array
253		{
254	8	$records = [];
255
256	8	foreach ($this->data as $key => $value) {
257	8	if (is_object($value) && method_exists($value, "jsonSerialize")) {
258	3	$records[$key] = $value->jsonSerialize();
259		} else {
260	8	$records[$key] = $value;
261		}
262		}
263
264	8	return $records;
265		}
266
267		/**
268		* Whether a offset exists
269		*
270		* @link https://php.net/manual/en/arrayaccess.offsetexists.php
271		*
272		* @param mixed $element
273		*
274		* @return bool
275		*/
276	16	public function offsetExists($element): bool
277		{
278	16	$element = (string) $element;
279
280	16	return $this->has($element);
281		}
282
283		/**
284		* Offset to retrieve
285		*
286		* @link https://php.net/manual/en/arrayaccess.offsetget.php
287		*
288		* @param mixed $element
289		*
290		* @return mixed
291		*/
292	17	public function offsetGet($element)
293		{
294	17	$element = (string) $element;
295
296	17	return $this->get($element);
297		}
298
299		/**
300		* Offset to set
301		*
302		* @link https://php.net/manual/en/arrayaccess.offsetset.php
303		*
304		* @param mixed $element
305		* @param mixed $value
306		*/
307	8	public function offsetSet($element, $value): void
308		{
309	8	$element = (string) $element;
310
311	8	$this->set($element, $value);
312	7	}
313
314		/**
315		* Offset to unset
316		*
317		* @link https://php.net/manual/en/arrayaccess.offsetunset.php
318		*
319		* @param mixed $element
320		*/
321	8	public function offsetUnset($element): void
322		{
323	8	$element = (string) $element;
324
325	8	$this->remove($element);
326	7	}
327
328		/**
329		* Delete the element from the collection
330		*
331		* @param string $element
332		*/
333	26	public function remove(string $element): void
334		{
335	26	if ($this->has($element)) {
336	22	if ($this->insensitive) {
337	22	$element = strtolower($element);
338		}
339
340	22	$value = $this->lowerKeys[$element];
341
342	22	unset($this->lowerKeys[$element]);
343	22	unset($this->data[$value]);
344		}
345	26	}
346
347		/**
348		* Set an element in the collection
349		*
350		* @param string $element
351		* @param mixed $value
352		*/
353	128	public function set(string $element, $value): void
354		{
355	128	$this->setData($element, $value);
356	128	}
357
358		/**
359		* String representation of object
360		*
361		* @link https://php.net/manual/en/serializable.serialize.php
362		*/
363	3	public function serialize(): string
364		{
365	3	return serialize($this->toArray());
366		}
367
368		/**
369		* Returns the object in an array format
370		*/
371	123	public function toArray(): array
372		{
373	123	return $this->data;
374		}
375
376		/**
377		* Returns the object in a JSON format
378		*
379		* The default string uses the following options for json_encode
380		*
381		* JSON_HEX_TAG, JSON_HEX_APOS, JSON_HEX_AMP, JSON_HEX_QUOT,
382		* JSON_UNESCAPED_SLASHES
383		*
384		* @see https://www.ietf.org/rfc/rfc4627.txt
385		*
386		* @param int $options
387		*
388		* @return string
389		*/
390	3	public function toJson(int $options = 79): string
391		{
392	3	return Json::encode($this->jsonSerialize(), $options);
393		}
394
395		/**
396		* Constructs the object
397		*
398		* @link https://php.net/manual/en/serializable.unserialize.php
399		*
400		* @param string $serialized
401		*/
402	3	public function unserialize($serialized): void
403		{
404	3	$serialized = (string) $serialized;
405	3	$data = unserialize($serialized);
406
407	3	$this->init($data);
408	3	}
409
410		/**
411		* Internal method to set data
412		*
413		* @param mixed $element
414		* @param mixed $value
415		*/
416	176	protected function setData($element, $value): void
417		{
418	176	$element = (string) $element;
419	176	$key = ($this->insensitive) ? mb_strtolower($element) : $element;
420
421	176	$this->data[$element] = $value;
422	176	$this->lowerKeys[$key] = $element;
423	176	}
424		}
425

niden / cardoe

Collection::__construct() A last analyzed 2020-03-02 03:47 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Collection::__construct() A
last analyzed 2020-03-02 03:47 UTC