Pinepain\ObjectMaps\ObjectMap

Complexity

Total Complexity

16

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

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

<?php declare(strict_types=1);

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 26 and the first side effect is on line 180.

/*
 * 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 Ref\WeakReference;

use Pinepain\ObjectMaps\Exceptions\OutOfBoundsException;
use Pinepain\ObjectMaps\Exceptions\OverflowException;

use function spl_object_hash;


class ObjectMap implements ObjectMapInterface
{
    use ObjectTypeHintTrait;

    protected $behavior = self::DEFAULT;

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

    /**
     * @param int $behavior
     */
    public function __construct(int $behavior = self::DEFAULT)

Possible parse error: non-abstract method defined as abstract

It is generally advisable to only define one property per statement.

    {
        $this->behavior = $behavior;
    }

    /**
     * {@inheritdoc}
     */
    public function put($key, $value)
    {
        $this->assertObject($key, 'Key');
        $this->assertObject($value, 'Value'); // while we may associate non-object value, for interface compatibility we don't do that

        $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)
    {
        $this->assertObject($key, '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
    {
        $this->assertObject($key, 'Key');

        $hash = $this->getHash($key);

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

    /**
     * {@inheritdoc}
     */
    public function remove($key)
    {
        $this->assertObject($key, '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 object $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): Bucket
    {
        if ($this->behavior & self::WEAK_KEY) {
            $key = $this->createReference($key, $hash);
        }

        if ($this->behavior & self::WEAK_VALUE) {
            $value = $this->createReference($value, $hash);
        }

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

    /**
     * @param        $obj
     * @param string $hash
     *
     * @return WeakReference
     */
    protected function createReference($obj, string $hash): WeakReference
    {
        return new WeakReference($obj, function () use ($hash) {
            $this->doRemove($hash);
        });
    }
}