WS\Utils\Collections\HashMap

Complexity

Total Complexity

23

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	put()	0	5	1
	remove()	0	9	?
A	hp$0 ➔ containsValue()	0	8	3
A	hp$0 ➔ stream()	0	3	1
	size()	0	3	?
	get()	0	8	?
A	hp$0 ➔ remove()	0	9	2
A	hp$0 ➔ key()	0	6	1
	stream()	0	3	?
A	hp$0 ➔ getKeyHash()	0	18	6
	values()	0	8	?
A	hp$0 ➔ values()	0	8	2
A	hp$0 ➔ size()	0	3	1
	getKeyHash()	0	18	?
	containsKey()	0	3	?
A	hp$0 ➔ get()	0	8	2
A	hp$0 ➔ getIterator()	0	19	1
A	hp$0 ➔ keys()	0	8	2
	getIterator()	0	19	?
A	hp$0 ➔ containsKey()	0	3	1
	keys()	0	8	?
A	hp$0 ➔ __construct()	0	7	1
	containsValue()	0	8	?

<?php
/**
 * @author Anton Lytkin <a.lytkin@worksolutions.ru>
 * @license MIT
 */

namespace WS\Utils\Collections;

use ArrayIterator;
use RuntimeException;

class HashMap implements Map
{
    private $entries = [];

    public function put($key, $value): bool
    {
        $this->entries[$this->getKeyHash($key)] = new MapEntry($key, $value);

        return true;
    }

    public function getIterator()
    {
        return new class($this->entries) extends ArrayIterator {
            private $entries;
            public function __construct(array $entries)
            {
                $hashToValueArray = array_map(static function (MapEntry $entry) {
                    return $entry->getValue();
                }, $entries);
                parent::__construct($hashToValueArray);
                $this->entries = $entries;
            }

            public function key()
            {
                $arrayKey = parent::key();
                /** @var MapEntry $entry */
                $entry = $this->entries[$arrayKey];
                return $entry->getKey();
            }
        };
    }

    public function values(): Collection
    {
        $values = [];
        /** @var MapEntry $entry */
        foreach ($this->entries as $entry) {
            $values[] = $entry->getValue();
        }
        return new ArrayList($values);
    }

    public function keys(): Collection
    {
        $keys = [];
        /** @var MapEntry $entry */
        foreach ($this->entries as $entry) {
            $keys[] = $entry->getKey();
        }
        return new ArrayList($keys);
    }

    /**
     * @param $key
     * @return string
     */
    private function getKeyHash($key): string
    {
        if (is_scalar($key)) {
            return $key.'';
        }
        if ($key instanceof HashCodeAware) {
            return $key->getHashCode();
        }
        if (is_object($key)) {
            return spl_object_hash($key);
        }
        if ($key === null) {
            return '__NULL__';
        }
        if (is_array($key)) {
            return md5(json_encode($key));
        }
        throw new RuntimeException("The type of $key is not supported");
    }

    public function remove($key): bool
    {
        $res = $this->containsKey($key);

        if (!$res) {
            return false;
        }
        unset($this->entries[$this->getKeyHash($key)]);
        return true;
    }

    /**
     * @inheritDoc
     */
    public function containsKey($key): bool
    {
        return isset($this->entries[$this->getKeyHash($key)]);
    }

    public function size(): int
    {
        return count($this->entries);
    }

    /**
     * @inheritDoc
     */
    public function get($key)
    {
        if (!$this->containsKey($key)) {
            return null;
        }

        $entry = $this->entries[$this->getKeyHash($key)];
        return $entry->getValue();
    }

    /**
     * @inheritDoc
     */
    public function containsValue($tested): bool
    {
        foreach ($this->entries as $entry) {
            if ($entry->getValue() === $tested) {
                return true;
            }
        }
        return false;
    }

    public function stream(): Stream
    {
        return new SerialStream(CollectionFactory::from(array_values($this->entries)));
    }
}