Collections\Traits\ConstMapLikeTrait

Complexity

Total Complexity

18

Size/Duplication

Total Lines	120
Duplicated Lines	14.17 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	17	17	4
A	isEmpty()	0	4	1
A	count()	0	4	1
A	at()	0	6	1
A	get()	0	8	2
A	containsKey()	0	4	1
A	contains()	0	4	1
A	offsetExists()	0	4	2
A	each()	0	8	2
A	toArray()	0	13	3

<?php

namespace Collections\Traits;

use Collections\Enumerable;

trait ConstMapLikeTrait
{
    use CommonContainerMethodsTrait;

    /**
     * @var array
     */
    private $container;

    protected function init($it = null)

This method seems to be duplicated in your project.

    {
        if (null !== $it) {
            $this->validateTraversable($it);

            $coll = [];
            foreach ($it as $key => $value) {
                if (is_array($value)) {
                    $value = new static($value);

The call to ConstMapLikeTrait::__construct() has too many arguments starting with $value.

                }
                $coll[$key] = $value;
            }
            $this->container = $coll;
        } else {
            $this->container = [];
        }
    }

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

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

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

        return $this->container[$key];
    }

    /**
     * {@inheritdoc}
     */
    public function get($index)
    {
        if ($this->containsKey($index)) {
            return $this->container[$index];
        }

        return null;
    }

    /**
     * {@inheritdoc}
     */
    public function containsKey($key)
    {
        return array_key_exists($key, $this->container);
    }

    /**
     * {@inheritdoc}
     */
    public function contains($element)
    {
        return in_array($element, $this->container, true);
    }


    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset)
    {
        return $this->containsKey($offset) && $this->at($offset) !== null;
    }

    /**
     * Returns an array containing the values from this VectorLike.
     */
    public function toArray()
    {
        $arr = [];
        foreach ($this as $key => $value) {

The expression $this of type this<Collections\Traits\ConstMapLikeTrait> is not traversable.

            if ($value instanceof Enumerable) {
                $arr[$key] = $value->toArray();
            } else {
                $arr[$key] = $value;
            }
        }

        return $arr;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function each(callable $callable)
    {
        foreach ($this as $k => $v) {

The expression $this of type this<Collections\Traits\ConstMapLikeTrait> is not traversable.

            $callable($v, $k);
        }

        return $this;
    }
}