Innmind\Compose\Lazy\Map

Complexity

Total Complexity

34

Size/Duplication

Total Lines	279
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

33 Methods

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

<?php

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 25 and the first side effect is on line 18.

declare(strict_types = 1);

namespace Innmind\Compose\Lazy;

use Innmind\Compose\Lazy;
use Innmind\Immutable\{
    MapInterface,
    Map as Base,
    Str,
    Sequence,
    Pair,
    SetInterface,
    StreamInterface,
    Exception\LogicException
};

final class Map implements MapInterface

Possible parse error: class missing opening or closing brace

{
    private $keyType;
    private $valueType;
    private $values;
    private $loaded;

    public function __construct(string $keyType, string $valueType)
    {
        $this->keyType = new Str($keyType);
        $this->valueType = new Str($valueType);
        $this->values = new Base('mixed', 'mixed');
    }

    public static function of(string $keyType, string $valueType, Pair ...$values): self
    {
        $self = new self($keyType, $valueType);
        $self->values = Sequence::of(...$values)->reduce(
            $self->values,
            static function(Base $map, Pair $pair): Base {
                return $map->put(
                    $pair->key(),
                    $pair->value()
                );
            }
        );

        return $self;
    }

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->get($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
    {
        return $this->loadedMap()->put($key, $value);
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function clear(): MapInterface
    {
        return new Base((string) $this->keyType, (string) $this->valueType);
    }

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): MapInterface
    {
        return $this->loadedMap()->map($function);
    }

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

    /**
     * {@inheritdoc}
     */
    public function remove($key): MapInterface
    {
        return $this->loadedMap()->remove($key);
    }

    /**
     * {@inheritdoc}
     */
    public function merge(MapInterface $map): MapInterface
    {
        return $this->loadedMap()->merge($map);
    }

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

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

    private function load($value)
    {
        if ($value instanceof Lazy) {
            return $value->load();
        }

        return $value;
    }

    private function loadedMap(): Base
    {
        return $this->loaded ?? $this->loaded = $this->values->reduce(
            $this->clear(),
            function(Base $map, $key, $value): Base {
                return $map->put(
                    $this->load($key),
                    $this->load($value)
                );
            }
        );
    }
}