Pinepain\ObjectMaps\ObjectBiMap

Complexity

Total Complexity

16

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	20	3
A	values()	0	19	3
A	get()	0	6	1
A	has()	0	6	1
A	count()	0	4	1
A	clear()	0	5	1
A	put()	0	18	3
A	remove()	0	19	3

<?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 22 and the first side effect is on line 166.

/*
 * 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 Pinepain\ObjectMaps\Exceptions\OutOfBoundsException;
use Pinepain\ObjectMaps\Exceptions\OverflowException;


class ObjectBiMap implements ObjectBiMapInterface
{
    use ObjectTypeHintTrait;

    protected $behavior = self::DEFAULT;

    /**
     * @var ObjectMap
     */
    protected $keys;
    /**
     * @var ObjectMap
     */
    protected $values;

    /**
     * @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.

    {
        $key_behavior   = 0;
        $value_behavior = 0;

The visibility should be declared for property $value_behavior.

        if ($behavior & self::WEAK_KEY) {

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

The visibility should be declared for property $behavior.

            $key_behavior   |= self::WEAK_KEY;
            $value_behavior |= self::WEAK_VALUE;

The visibility should be declared for property $value_behavior.

        }

        if ($behavior & self::WEAK_VALUE) {

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

The visibility should be declared for property $behavior.

            $key_behavior   |= self::WEAK_VALUE;
            $value_behavior |= self::WEAK_KEY;

The visibility should be declared for property $value_behavior.

        }

        $this->keys   = new ObjectMap($key_behavior);

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

The visibility should be declared for property $this.

        $this->values = new ObjectMap($value_behavior);

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

The visibility should be declared for property $this.

        $this->behavior = $behavior;

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

The visibility should be declared for property $this.

    }

    /**
     * {@inheritdoc}
     */
    public function values(): ObjectBiMapInterface
    {
        $new_behavior = 0;

        if ($this->behavior & self::WEAK_KEY) {
            $new_behavior |= self::WEAK_VALUE;
        }

        if ($this->behavior & self::WEAK_VALUE) {
            $new_behavior |= self::WEAK_KEY;
        }

        $new = new static($new_behavior);

        $new->keys   = $this->values;
        $new->values = $this->keys;

        return $new;
    }

    /**
     * {@inheritdoc}
     */
    public function put($key, $value)
    {
        $this->assertObject($key, 'Key');

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

        $this->assertObject($value, 'Value');

        if ($this->values->has($value)) {
            // UNEXPECTED
            throw new OverflowException('Key with such value already exists');
        }

        $this->keys->put($key, $value);
        $this->values->put($value, $key);
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        $this->assertObject($key, 'Key');

        return $this->keys->get($key);
    }

    /**
     * {@inheritdoc}
     */

    public function has($key): bool
    {
        $this->assertObject($key, 'Key');

        return $this->keys->has($key);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key)
    {
        $this->assertObject($key, 'Key');

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

        $value = $this->keys->remove($key);

        if (!$this->values->has($value)) {
            // UNEXPECTED
            throw new OutOfBoundsException('Key with such value not found');
        }

        $this->values->remove($value);

        return $value;
    }

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

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