Pinepain\ObjectMaps\ObjectMap

Complexity

Total Complexity

15

Size/Duplication

Total Lines	139
Duplicated Lines	7.19 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

40.91%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	put()	0	12	2
A	get()	0	10	2
A	has()	0	6	1
A	remove()	0	14	2
A	count()	0	4	1
A	clear()	0	4	1
A	getHash()	0	4	1
A	doRemove()	0	4	1
A	createBucket()	10	16	3

<?php declare(strict_types=1);

/*
 * This file is part of the pinepain/php-object-maps PHP library.
 *
 * Copyright (c) 2016-2017 Bogdan Padalko <pinepain@gmail.com>
 *
 * Licensed under the MIT license: http://opensource.org/licenses/MIT
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code or visit http://opensource.org/licenses/MIT
 */


namespace Pinepain\ObjectMaps;


use OutOfBoundsException;
use OverflowException;
use Ref\WeakReference;

use function spl_object_hash;


class ObjectMap implements ObjectMapInterface
{
    const WEAK_KEY = 1 << 0;
    const WEAK_VALUE = 1 << 1;
    const WEAK_KEY_VALUE = self::WEAK_KEY | self::WEAK_VALUE;

    protected $behavior = 0;

    /**
     * @var Bucket[]
     */
    protected $keys = [];

    /**
     * @param int $behavior
     */
    public function __construct(int $behavior = 0)
    {
        $this->behavior = $behavior;
    }

    /**
     * {@inheritdoc}
     */
    public function put($key, $value)
    {
        $hash = $this->getHash($key);

        if (isset($this->keys[$hash])) {
            throw new OverflowException('Value with such key already exists');
        }

        $bucket = $this->createBucket($key, $value, $hash);

        $this->keys[$hash] = $bucket;
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        $hash = $this->getHash($key);

        if (!isset($this->keys[$hash])) {
            throw new OutOfBoundsException('Value with such key not found');
        }

        return $this->keys[$hash]->value;
    }

    /**
     * {@inheritdoc}
     */
    public function has($key): bool
    {
        $hash = $this->getHash($key);

        return isset($this->keys[$hash]);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key)
    {
        $hash = $this->getHash($key);

        if (!isset($this->keys[$hash])) {
            throw new OutOfBoundsException('Value with such key not found');
        }

        $bucket = $this->keys[$hash];

        $this->doRemove($hash);

        return $bucket->value;
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        return count($this->keys);
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        $this->keys = [];
    }

    /**
     * @param $value
     *
     * @return string
     */
    protected function getHash($value)
    {
        return spl_object_hash($value);
    }

    /**
     * @param string $hash
     *
     * @return void
     */
    protected function doRemove(string $hash)
    {
        unset($this->keys[$hash]);
    }

    /**
     * @param object $key
     * @param object $value
     * @param string $hash
     *
     * @return Bucket
     */
    protected function createBucket($key, $value, string $hash)
    {
        if ($this->behavior & self::WEAK_KEY) {

This code seems to be duplicated across your project.

            $key = new WeakReference($key, function () use ($hash) {
                $this->doRemove($hash);
            });
        }

        if ($this->behavior & self::WEAK_VALUE) {

This code seems to be duplicated across your project.

            $value = new WeakReference($value, function () use ($hash) {
                $this->doRemove($hash);
            });
        }

        return new Bucket($key, $value);
    }
}