Phalcon\Registry

Complexity

Total Complexity

23

Size/Duplication

Total Lines	247
Duplicated Lines	0 %

Test Coverage

Coverage

59.78%

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	unserialize()	0	3	1
A	init()	0	3	1
A	count()	0	3	1
A	serialize()	0	3	1
A	clear()	0	3	1
A	__construct()	0	3	1
A	__get()	0	3	1
A	has()	0	3	1
A	__set()	0	3	1
A	__isset()	0	3	1
A	toArray()	0	3	1
A	offsetGet()	0	3	1
A	offsetExists()	0	3	1
A	get()	0	6	1
A	remove()	0	3	1
A	__unset()	0	3	1
A	jsonSerialize()	0	3	1
A	toJson()	0	3	1
A	getIterator()	0	4	2
A	offsetSet()	0	3	1
A	offsetUnset()	0	3	1
A	set()	0	3	1

<?php

/**
 * This file is part of the Phalcon Framework.
 *
 * (c) Phalcon Team <team@phalcon.io>
 *
 * 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 Generator;
use Traversable;

/**
 * Phalcon\Registry
 *
 * A registry is a container for storing objects and values in the application
 * space. By storing the value in a registry, the same object is always
 * available throughout your application.
 *
 *```php
 * $registry = new \Phalcon\Registry();
 *
 * // Set value
 * $registry->something = "something";
 * // or
 * $registry["something"] = "something";
 *
 * // Get value
 * $value = $registry->something;
 * // or
 * $value = $registry["something"];
 *
 * // Check if the key exists
 * $exists = isset($registry->something);
 * // or
 * $exists = isset($registry["something"]);
 *
 * // Unset
 * unset($registry->something);
 * // or
 * unset($registry["something"]);
 *```
 *
 * In addition to ArrayAccess, Phalcon\Registry also implements Countable
 * (count($registry) will return the number of elements in the registry),
 * Serializable and Iterator (you can iterate over the registry using a foreach
 * loop) interfaces. For PHP 5.4 and higher, JsonSerializable interface is
 * implemented.
 *
 * Phalcon\Registry is very fast (it is typically faster than any userspace
 * implementation of the registry); however, this comes at a price:
 * Phalcon\Registry is a final class and cannot be inherited from.
 *
 * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count()
 * etc, it is not recommended to invoke them manually (these methods exist
 * mainly to match the interfaces the registry implements):
 * $registry->__get("property") is several times slower than
 * $registry->property.
 *
 * Internally all the magic methods (and interfaces except JsonSerializable)
 * are implemented using object handlers or similar techniques: this allows to
 * bypass relatively slow method calls.
 */
final class Registry extends Collection
{
    /**
     * Registry constructor.
     *
     * @param array|null $data
     */
    final public function __construct(array $data = [])
    {
        parent::__construct($data);
    }

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

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

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

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

    /**
     * Clears the internal collection
     */
    final public function clear(): void
    {
        parent::clear();
    }

    /**
     * Count elements of an object
     *
     * @link https://php.net/manual/en/countable.count.php
     */
    final public function count(): int
    {
        return parent::count();
    }

    /**
     * Get the element from the collection
     *
     * @param string      $element
     * @param mixed|null  $defaultValue
     * @param string|null $cast
     *
     * @return mixed|null
     */
    final public function get(
        string $element,
        $defaultValue = null,
        string $cast = null
    ) {
        return parent::get($element, $defaultValue, $cast);
    }

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

    /**
     * Get the element from the collection
     *
     * @param string $element
     *
     * @return bool
     */
    final public function has(string $element): bool
    {
        return parent::has($element);
    }

    /**
     * Initialize internal array
     *
     * @param array $data
     */
    final public function init(array $data = []): void
    {
        parent::init($data);
    }

    /**
     * Specify data which should be serialized to JSON
     *
     * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
     */
    final public function jsonSerialize(): array
    {
        return parent::jsonSerialize();
    }

    /**
     * Whether a offset exists
     *
     * @param mixed $element
     *
     * @return bool
     */
    final public function offsetExists($element): bool
    {
        return parent::has($element);
    }

    /**
     * Offset to retrieve
     *
     * @param mixed $element
     *
     * @return mixed|null
     */
    final public function offsetGet($element)
    {
        return parent::get($element);
    }

    /**
     * Offset to set
     *
     * @param mixed $element
     * @param mixed $value
     */
    final public function offsetSet($element, $value): void
    {
        parent::set($element, $value);
    }

    /**
     * Offset to unset
     *
     * @param mixed $element
     */
    final public function offsetUnset($element): void
    {
        parent::remove($element);
    }

    /**
     * Delete the element from the collection
     *
     * @param string $element
     */
    final public function remove(string $element): void
    {
        parent::remove($element);
    }

    /**
     * String representation of object
     *
     * @link https://php.net/manual/en/serializable.serialize.php
     */
    final public function serialize(): string
    {
        return parent::serialize();
    }

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

    /**
     * Returns the object in an array format
     */
    final public function toArray(): array
    {
        return parent::toArray();
    }

    /**
     * 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
     */
    final public function toJson(int $options = 79): string
    {
        return parent::toJson($options);
    }

    /**
     * Constructs the object
     *
     * @param string $serialized
     */
    final public function unserialize($serialized): void
    {
        parent::unserialize($serialized);
    }
}