GenericCollections\TypedStruct

Complexity

Total Complexity

27

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	18	5
A	getDefinitions()	0	4	1
A	getDefinition()	0	5	1
A	setValues()	0	8	3
A	set()	0	8	2
A	exists()	0	4	1
A	get()	0	5	1
A	getValues()	0	4	1
A	checkDefinitionExists()	0	6	2
A	__get()	0	4	1
A	__set()	0	4	1
A	__isset()	0	4	1
A	__unset()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	getIterator()	0	4	1
A	count()	0	4	1

<?php
namespace GenericCollections;

use GenericCollections\Exceptions\TypePropertyException;
use GenericCollections\Utils\TypeProperty;

/**
 * Concrete TypedStruct implementation. This class is like a HHVM Shape.
 * All defined keys can be accessed as properties or array.
 * It will throw a TypePropertyException if you try to set a value that does not match the definition type
 *
 * You can use this as a direct object like:
 * ```php
 * $obj = new TypedStruct(
 *      ['id' => 'int', 'name' => 'string'],
 *      ['id' => 1, 'name' => 'Foo Bar]
 * );
 * echo $obj['name']; // Foo Bar
 * ```
 *
 * Or you can inherith from this class to your own definition
 * ```php
 * class UserData extends TypedStruct
 * {
 *      public function __construct(array $values = [])
 *      {
 *          $definitions = ['id' => 'int', 'name' => 'string'];
 *          parent::__construct($definitions, $values);
 *      }
 * }
 * $user = new UserData(['id' => 10]);
 * echo $obj['id']; // 10
 * ```
 *
 * @package GenericCollections
 */
class TypedStruct implements \ArrayAccess, \IteratorAggregate, \Countable
{
    /**
     * @var TypeProperty[] Definition of the (string) key => (string) type
     */
    protected $definitions = [];

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

    /**
     * TypedStruct constructor.
     * @param string[] $definitions
     * @param array $values
     */
    public function __construct(array $definitions, array $values = [])
    {
        foreach ($definitions as $key => $type) {
            if (is_int($key)) {
                $key = $type;
                $type = 'mixed';
            }
            if (! is_string($key)) {
                throw new \InvalidArgumentException('Invalid definition key found');
            }
            if (! is_string($type)) {
                throw new \InvalidArgumentException('Invalid definition type found');
            }
            $this->definitions[$key] = new TypeProperty($type, true);
            $this->values[$key] = null;
        }
        $this->setValues($values);
    }

    /**
     * @return TypeProperty[] Get an array with all definitions
     */
    public function getDefinitions()
    {
        return $this->definitions;
    }

    /**
     * Retrieve a definition object
     * @param string $key
     * @return TypeProperty
     * @throws \InvalidArgumentException if key is not found
     */
    public function getDefinition($key)
    {
        $this->checkDefinitionExists($key);
        return $this->definitions[$key];
    }

    /**
     * Set all the values from the array to the local object
     * If the key is not found then it is just ignored
     *
     * @param array $values
     */
    public function setValues(array $values)
    {
        foreach ($values as $key => $value) {
            if ($this->exists($key)) {
                $this->set($key, $value);
            }
        }
    }

    /**
     * Set the value for a key, this will check that the value is the same type of the definition
     *
     * @param string $key
     * @param mixed $value
     * @throws \InvalidArgumentException if key is not found
     * @throws TypePropertyException if the value does not match the defined type
     */
    public function set($key, $value)
    {
        $definition = $this->getDefinition($key);
        if (! $definition->check($value)) {
            throw new TypePropertyException("Definition '$key' only allows type '{$definition->getType()}'");
        }
        $this->values[$key] = $value;
    }

    /**
     * Return TRUE if the key exists
     *
     * @param string $key
     * @return bool
     */
    public function exists($key)
    {
        return array_key_exists($key, $this->definitions);
    }

    /**
     * Return the value of a key
     *
     * @param string $key
     * @return mixed
     * @throws \InvalidArgumentException if key is not found
     */
    public function get($key)
    {
        $this->checkDefinitionExists($key);
        return $this->values[$key];
    }

    /**
     * Return an array with the key and values
     *
     * @return array
     */
    public function getValues()
    {
        return $this->values;
    }

    /**
     * Utility function that throws an exception if the key is not found
     * @param string $key
     */
    protected function checkDefinitionExists($key)
    {
        if (! array_key_exists($key, $this->definitions)) {
            throw new \InvalidArgumentException("Definition '$key' does not exists");
        }
    }

    public function __get($name)
    {
        return $this->get($name);
    }

    public function __set($name, $value)
    {
        $this->set($name, $value);
    }

    public function __isset($name)
    {
        return isset($this->values[$name]);
    }

    public function __unset($name)
    {
        $this->set($name, null);
    }

    public function offsetExists($offset)
    {
        return isset($this->values[$offset]);
    }

    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    public function offsetSet($offset, $value)
    {
        $this->set($offset, $value);
    }

    public function offsetUnset($offset)
    {
        $this->set($offset, null);
    }

    public function getIterator()
    {
        return new \ArrayIterator($this->values);
    }

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