Daikon\DataStructure\MapTrait

Complexity

Total Complexity

24

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Test Coverage

Coverage

98.7%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__clone()	0	3	1
A	get()	0	11	3
A	count()	0	4	1
A	isEmpty()	0	4	1
A	equals()	0	4	1
A	assertValidType()	0	8	3
A	keys()	0	4	1
A	getIterator()	0	3	1
A	__get()	0	3	1
A	last()	0	5	1
A	has()	0	4	1
A	with()	0	7	1
A	first()	0	5	1
A	assertValidMap()	0	6	1
A	assertInitialized()	0	3	1
A	init()	0	10	2
A	without()	0	7	1
A	assertValidKey()	0	3	1
A	unwrap()	0	4	1

<?php declare(strict_types=1);
/**
 * This file is part of the daikon-cqrs/data-structure project.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Daikon\DataStructure;

use Daikon\Interop\Assert;
use Daikon\Interop\Assertion;
use Ds\Map;

This use statement conflicts with another class in this namespace, Daikon\DataStructure\Map. Consider defining an alias.

trait MapTrait
{
    protected Map $compositeMap;

    protected function init(iterable $values): void
    {
        Assertion::false(isset($this->compositeMap), 'Cannot reinitialize map.');

        foreach ($values as $key => $value) {
            $this->assertValidKey($key);
            $this->assertValidType($value);
        }

        $this->compositeMap = new Map($values);
    }

    public function keys(): array
    {
        $this->assertInitialized();
        return $this->compositeMap->keys()->toArray();
    }

    public function has(string $key): bool
    {
        $this->assertInitialized();
        return $this->compositeMap->hasKey($key);
    }

    public function get(string $key, $default = null)
    {
        $this->assertInitialized();
        if (func_num_args() === 1) {
            Assertion::satisfy($key, [$this, 'has'], "Key '$key' not found and no default provided.");
            return $this->compositeMap->get($key);
        } else {
            if (!is_null($default)) {
                $this->assertValidType($default);
            }
            return $this->compositeMap->get($key, $default);
        }
    }

    public function with(string $key, $value): self
    {
        $this->assertInitialized();
        $this->assertValidType($value);
        $copy = clone $this;
        $copy->compositeMap->put($key, $value);
        return $copy;
    }

    public function without(string $key): self
    {
        $this->assertInitialized();
        Assertion::satisfy($key, [$this, 'has'], "Key '$key' not found.");
        $copy = clone $this;
        $copy->compositeMap->remove($key);
        return $copy;
    }

    public function first()
    {
        $this->assertInitialized();
        /** @psalm-suppress MissingPropertyType */
        return $this->compositeMap->first()->value;
    }

    public function last()
    {
        $this->assertInitialized();
        /** @psalm-suppress MissingPropertyType */
        return $this->compositeMap->last()->value;
    }

    public function isEmpty(): bool
    {
        $this->assertInitialized();
        return $this->compositeMap->isEmpty();
    }

    /** @param static $map */
    public function equals($map): bool
    {
        $this->assertValidMap($map);
        return $this->unwrap() === $map->unwrap();
    }

    public function count(): int
    {
        $this->assertInitialized();
        return $this->compositeMap->count();
    }

    public function unwrap(): array
    {
        $this->assertInitialized();
        return $this->compositeMap->toArray();
    }

    /** @psalm-suppress ImplementedReturnTypeMismatch */
    public function getIterator(): Map
    {
        return $this->compositeMap;
    }

    protected function assertInitialized(): void
    {
        Assertion::true(isset($this->compositeMap), 'Map is not initialized.');
    }

    /** @param mixed $key */
    protected function assertValidKey($key): void
    {
        Assert::that($key, 'Key must be a valid string.')->string()->notEmpty();
    }

    /** @param mixed $value */
    protected function assertValidType($value): void
    {
        Assertion::true(
            is_array($value) || is_scalar($value),
            sprintf(
                "Invalid value type given to '%s', expected scalar or array but was given '%s'.",
                static::class,
                is_object($value) ? get_class($value) : @gettype($value)
            )
        );
    }

    /** @param mixed $map */
    protected function assertValidMap($map): void
    {
        Assertion::isInstanceOf(
            $map,
            static::class,
            sprintf("Map operation must be on same type as '%s'.", static::class)
        );
    }

    public function __get(string $key)
    {
        return $this->get($key);
    }

    public function __clone()
    {
        $this->compositeMap = clone $this->compositeMap;
    }
}