OldTown\PropertySet\Providers\Memory\MemoryPropertySet

Complexity

Total Complexity

18

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
C	getKeys()	0	23	7
A	getType()	0	9	2
A	exists()	0	6	1
A	remove()	0	6	1
A	getMap()	0	4	1
A	setImpl()	0	18	3
A	get()	0	15	3

<?php
/**
 * @link https://github.com/old-town/old-town-propertyset
 * @author  Malofeykin Andrey  <and-rey2@yandex.ru>
 */
namespace OldTown\PropertySet\Providers\Memory;

use \OldTown\PropertySet\AbstractPropertySet;
use OldTown\PropertySet\Exception;


/**
 * Class PropertySetManager
 *
 * @package OldTown\PropertySet
 */
class MemoryPropertySet extends AbstractPropertySet
{
    /**
     * @var ValueEntry[]
     */
    protected $map = [];

    /**
     * @param string|null  $prefix
     * @param integer|null $type
     *
     * @return array
     *
     * @throws Exception\PropertyException
     */
    public function getKeys($prefix = null, $type = null)
    {
        $map = $this->getMap();
        $keys = array_keys($map);

        $result = [];

        foreach ($keys as $key) {
            if (null === $prefix || (is_string($prefix) && strpos($key, $prefix))) {
                if (0 === $type) {
                    $result[$key] = $key;
                } else {
                    $v = $map[$key];

                    if ($type === $v->getType()) {
                        $result[$key] = $key;
                    }
                }
            }
        }

        return $result;
    }

    /**
     * @param string $key
     *
     * @return integer
     *
     * @throws Exception\PropertyException
     */
    public function getType($key)
    {
        $map = $this->getMap();
        if (array_key_exists($key, $map)) {
            $type = $map[$key]->getType();
            return $type;
        }
        return 0;
    }

    /**
     * @param string $key
     *
     * @return boolean
     *
     * @throws \OldTown\PropertySet\Exception\PropertyException
     */
    public function exists($key)
    {
        $exists = $this->getType($key) > 0;

        return $exists;
    }

    /**
     * @param string $key
     *
     * @return $this
     *
     * @throws Exception\PropertyException
     */
    public function remove($key)
    {
        $this->map = [];

        return $this;
    }


    /**
     * @return ValueEntry[]
     */
    protected function getMap()
    {
        return $this->map;
    }



    /**
     * @param integer $type
     * @param string $key
     * @param mixed $value
     *
     * @return $this
     *
     * @throws Exception\PropertyException
     */
    protected function setImpl($type, $key, $value)
    {
        if ($this->exists($key)) {
            $v = $this->getMap()[$key];

            if ($type !== $v->getType()) {
                $errMsg = 'Ошибка с типами';
                throw new Exception\DuplicatePropertyKeyException($errMsg);
            }

            $v->setValue($value);
        } else {
            $valueEntry = new ValueEntry($type, $value);
            $this->map[$key] = $valueEntry;
        }

        return $this;
    }

    /**
     * @param integer $type
     * @param string $key
     *
     * @return mixed
     *
     * @throws Exception\InvalidPropertyTypeException
     * @throws \OldTown\PropertySet\Exception\PropertyException
     * @throws \OldTown\PropertySet\Exception\DuplicatePropertyKeyException
     */
    protected function get($type, $key)
    {
        if ($this->exists($key)) {
            $v = $this->getMap()[$key];

            if ($type !== $v->getType()) {
                $errMsg = 'Ошибка с типами';
                throw new Exception\DuplicatePropertyKeyException($errMsg);
            }

            $value = $v->getValue();
            return $value;
        }
        return null;
    }
}