Innmind\Immutable\Map

Complexity

Total Complexity

36

Size/Duplication

Total Lines	313
Duplicated Lines	0 %

Test Coverage

Coverage

98.91%

Importance

Changes

0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	partition()	0	3	1
A	current()	0	3	1
A	offsetUnset()	0	3	1
A	__construct()	0	10	3
A	contains()	0	3	1
A	size()	0	3	1
A	foreach()	0	5	1
A	count()	0	3	1
A	put()	0	6	1
A	offsetGet()	0	3	1
A	merge()	0	6	1
A	of()	0	20	3
A	__invoke()	0	3	1
A	get()	0	3	1
A	remove()	0	6	1
A	keyType()	0	3	1
A	clear()	0	6	1
A	offsetSet()	0	3	1
A	filter()	0	6	1
A	key()	0	3	1
A	rewind()	0	3	1
A	reduce()	0	3	1
A	groupBy()	0	3	1
A	equals()	0	3	1
A	valid()	0	3	1
A	keys()	0	3	1
A	join()	0	3	1
A	next()	0	3	1
A	values()	0	3	1
A	map()	0	6	1
A	offsetExists()	0	3	1
A	valueType()	0	3	1

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\{
    Exception\InvalidArgumentException,
    Exception\LogicException,
    Exception\ElementNotFoundException,
    Exception\GroupEmptyMapException
};

final class Map implements MapInterface
{
    private $implementation;

    /**
     * {@inheritdoc}
     */
    public function __construct(string $keyType, string $valueType)
    {
        $type = Type::of($keyType);

        if ($type instanceof ClassType) {

The type Innmind\Immutable\ClassType was not found. Maybe you did not declare it correctly or list all dependencies?

            $this->implementation = new Map\ObjectKeys($keyType, $valueType);
        } else if (\in_array($keyType, ['int', 'integer', 'string'], true)) {
            $this->implementation = new Map\Primitive($keyType, $valueType);
        } else {
            $this->implementation = new Map\DoubleIndex($keyType, $valueType);
        }
    }

    public static function of(
        string $key,
        string $value,
        array $keys = [],
        array $values = []
    ): self {
        $keys = \array_values($keys);
        $values = \array_values($values);

        if (\count($keys) !== \count($values)) {
            throw new LogicException('Different sizes of keys and values');
        }

        $self = new self($key, $value);

        foreach ($keys as $i => $key) {
            $self = $self->put($key, $values[$i]);
        }

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function keyType(): Str
    {
        return $this->implementation->keyType();
    }

    /**
     * {@inheritdoc}
     */
    public function valueType(): Str
    {
        return $this->implementation->valueType();
    }

    /**
     * {@inheritdoc}
     */
    public function size(): int
    {
        return $this->implementation->size();
    }

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

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

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

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->implementation->next();
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->implementation->rewind();
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset): bool
    {
        return $this->implementation->offsetExists($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->implementation->offsetGet($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        throw new LogicException('You can\'t modify a map');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        throw new LogicException('You can\'t modify a map');
    }

    /**
     * {@inheritdoc}
     */
    public function put($key, $value): MapInterface
    {
        $map = clone $this;
        $map->implementation = $this->implementation->put($key, $value);

        return $map;
    }

    /**
     * Alias for put method in order to have a syntax similar to a true tuple
     * when constructing the map
     *
     * Example:
     * <code>
     * Map::of('int', 'int')
     *     (1, 2)
     *     (3, 4)
     * </code>
     *
     * @param T $key
     * @param S $value
     *
     * @return self<T, S>
     */
    public function __invoke($key, $value): self
    {
        return $this->put($key, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        return $this->implementation->get($key);
    }

    /**
     * {@inheritdoc}
     */
    public function contains($key): bool
    {
        return $this->implementation->contains($key);
    }

    /**
     * {@inheritdoc}
     */
    public function clear(): MapInterface
    {
        $map = clone $this;
        $map->implementation = $this->implementation->clear();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(MapInterface $map): bool
    {
        return $this->implementation->equals($map);
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): MapInterface
    {
        $map = $this->clear();
        $map->implementation = $this->implementation->filter($predicate);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): MapInterface
    {
        $this->implementation->foreach($function);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(callable $discriminator): MapInterface
    {
        return $this->implementation->groupBy($discriminator);
    }

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

    /**
     * {@inheritdoc}
     */
    public function values(): StreamInterface
    {
        return $this->implementation->values();
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): MapInterface
    {
        $map = $this->clear();
        $map->implementation = $this->implementation->map($function);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function join(string $separator): Str
    {
        return $this->implementation->join($separator);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key): MapInterface
    {
        $map = clone $this;
        $map->implementation = $this->implementation->remove($key);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function merge(MapInterface $map): MapInterface
    {
        $self = clone $this;
        $self->implementation = $this->implementation->merge($map);

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        return $this->implementation->partition($predicate);
    }

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        return $this->implementation->reduce($carry, $reducer);
    }
}