Collections\Traits\CommonContainerMethodsTrait

Complexity

Total Complexity

59

Size/Duplication

Total Lines	394
Duplicated Lines	12.69 %

Coupling/Cohesion

Components	1
Dependencies	21

Importance

Changes	1
Bugs	0	Features	0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefaultComparer()	0	8	2
A	setDefaultComparer()	0	6	1
A	__toString()	0	4	1
A	equals()	0	4	1
A	serialize()	0	4	1
A	unserialize()	0	6	1
A	jsonSerialize()	0	4	1
A	toValuesArray()	13	13	3
A	toKeysArray()	0	9	2
A	toArray()	13	13	3
A	fromArray()	0	13	3
A	toVector()	0	4	1
A	toImmVector()	0	4	1
A	toSet()	0	4	1
A	toImmSet()	0	4	1
A	toMap()	0	4	1
A	toImmMap()	0	4	1
A	map()	0	4	1
A	mapWithKey()	0	4	1
A	filter()	0	4	1
A	filterWithKey()	0	4	1
A	zip()	12	12	3
A	take()	0	8	2
A	takeWhile()	0	4	1
A	skip()	0	8	2
A	skipWhile()	0	4	1
A	slice()	0	11	3
A	first()	0	8	2
A	last()	0	10	2
A	each()	0	8	2
A	exists()	0	10	3
A	concatAll()	12	12	1
A	groupBy()	0	16	4
A	indexBy()	0	10	2
A	reduce()	0	8	2

<?php

namespace Collections\Traits;

use Collections\ArrayList;
use Collections\Comparer\NumericKeyComparer;
use Collections\Dictionary;
use Collections\Generic\ComparerInterface;
use Collections\Immutable\ImmArrayList;
use Collections\Immutable\ImmDictionary;
use Collections\Immutable\ImmSet;
use Collections\Iterable;
use Collections\Iterator\LazyFilterIterable;
use Collections\Iterator\LazyFilterKeyedIterable;
use Collections\Iterator\LazyMapIterable;
use Collections\Iterator\LazyMapWithKeyIterable;
use Collections\Iterator\LazySkipIterable;
use Collections\Iterator\LazySkipWhileIterable;
use Collections\Iterator\LazySliceIterable;
use Collections\Iterator\LazyTakeIterable;
use Collections\Iterator\LazyTakeWhileIterable;
use Collections\Iterator\LazyZipIterable;
use Collections\Pair;
use Collections\Set;
use Collections\VectorInterface;

trait CommonContainerMethodsTrait
{
    use GuardTrait;
    /**
     * @var ComparerInterface
     */
    private $defaultComparer;

    /**
     * Gets the default comparer for this collection
     * @return ComparerInterface
     */
    public function getDefaultComparer()
    {
        if ($this->defaultComparer === null) {
            $this->defaultComparer = new NumericKeyComparer();
        }

        return $this->defaultComparer;
    }

    /**
     * Sets the default comparer for this collection
     * @param ComparerInterface $defaultComparer
     * @return $this
     */
    public function setDefaultComparer(ComparerInterface $defaultComparer)
    {
        $this->defaultComparer = $defaultComparer;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function __toString()
    {
        return get_class($this);
    }

    public function equals($obj)
    {
        return ($obj === $this);
    }

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

The property container does not exist. Did you maybe forget to declare it?

    }

    /**
     * {@inheritdoc}
     */
    public function unserialize($serialized)
    {
        $this->container = unserialize($serialized);

        return $this->container;
    }

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

    /**
     * @return array
     */
    public function toValuesArray()

This method seems to be duplicated in your project.

    {
        $arr = [];
        foreach ($this as $value) {

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

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

        return $arr;
    }

    public function toKeysArray()
    {
        $res = [];
        foreach ($this as $k => $_) {

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

            $res[] = $k;
        }

        return $res;
    }

    /**
     * {@inheritdoc}
     */
    public function toArray()

This method seems to be duplicated in your project.

    {
        $arr = [];
        foreach ($this as $key => $value) {

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

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

        return $arr;
    }

    /**
     * {@inheritdoc}
     */
    public static function fromArray(array $arr)
    {
        $map = new static();
        foreach ($arr as $k => $v) {
            if (is_array($v)) {
                $map[$k] = new static($v);

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with $v.

            } else {
                $map[$k] = $v;
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function toVector()
    {
        return new ArrayList($this);
    }

    /**
     * {@inheritdoc}
     */
    public function toImmVector()
    {
        return new ImmArrayList($this);
    }

    /**
     * {@inheritdoc}
     */
    public function toSet()
    {
        return new Set($this);
    }

    /**
     * {@inheritdoc}
     */
    public function toImmSet()
    {
        return new ImmSet($this);
    }

    /**
     * {@inheritdoc}
     */
    public function toMap()
    {
        return new Dictionary($this);
    }

    /**
     * {@inheritdoc}
     */
    public function toImmMap()
    {
        return new ImmDictionary($this);
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function map(callable $callable)
    {
        return new static(new LazyMapIterable($this, $callable));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyMapIterable($this, $callable).

    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function mapWithKey($callback)
    {
        return new static(new LazyMapWithKeyIterable($this, $callback));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyMapWithKeyIterable($this, $callback).

    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function filter(callable $callable)
    {
        return new static(new LazyFilterIterable($this, $callable));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyFilterIterable($this, $callable).

    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function filterWithKey($callback)
    {
        return new static(new LazyFilterKeyedIterable($this, $callback));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyFilterKeyedIterable($this, $callback).

    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function zip(Iterable $iterable)

This method seems to be duplicated in your project.

    {
        if (is_array($iterable)) {
            $iterable = new ImmArrayList($iterable);
        }

        if ($iterable instanceof \Traversable) {
            return new static(new LazyZipIterable($this, $iterable));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyZipIterable($this, $iterable).

        } else {
            throw new \InvalidArgumentException('Parameter must be an array or an instance of Traversable');
        }
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function take($size = 1)
    {
        if (!is_int($size)) {
            throw new \InvalidArgumentException('Parameter n must be an integer');
        }

        return new static(new LazyTakeIterable($this, $size));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyTakeIterable($this, $size).

    }

    public function takeWhile(callable $callable)
    {
        return new static(new LazyTakeWhileIterable($this, $callable));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazyTakeWhileIterable($this, $callable).

    }

    public function skip($n)
    {
        if (!is_int($n)) {
            throw new \InvalidArgumentException('Parameter n must be an integer');
        }

        return new static(new LazySkipIterable($this, $n));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazySkipIterable($this, $n).

    }

    public function skipWhile(callable $callable)
    {
        return new static(new LazySkipWhileIterable($this, $callable));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazySkipWhileIterable($this, $callable).

    }

    public function slice($start, $length)
    {
        if ($start < 0) {
            throw new \InvalidArgumentException('Parameter start must be a non-negative integer');
        }
        if ($length < 0) {
            throw new \InvalidArgumentException('Parameter len must be a non-negative integer');
        }

        return new static(new LazySliceIterable($this, $start, $length));

The call to CommonContainerMethodsTrait::__construct() has too many arguments starting with new \Collections\Iterator\LazySliceIterable($this, $start, $length).

    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function first()
    {
        if ($this->isEmpty()) {
            return null;
        }

        return current($this->container);
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function last()
    {
        if ($this->isEmpty()) {
            return null;
        }

        $lastItem = array_slice($this->container, -1, 1);

        return current($lastItem);
    }

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

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

            $callable($v);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function exists(callable $fn)
    {
        foreach ($this as $element) {

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

            if ($fn($element)) {
                return true;
            }
        }

        return false;
    }

    public function concatAll()

This method seems to be duplicated in your project.

    {
        /** @var VectorInterface $results */
        $results = new static();
        $this->each(function (Iterable $subArray) use ($results) {
            $subArray->each(function ($item) use ($results) {
                $results->add($item);
            });
        });

        return $results;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function groupBy($callback)
    {
        $group = new Dictionary();
        foreach ($this as $value) {

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

            $key = $callback($value);
            if (!$group->containsKey($key)) {
                $element = $this instanceof VectorInterface ? new static([$value]) : new ArrayList([$value]);

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

                $group->add(new Pair($key, $element));
            } else {
                $value = $group->get($key)->add($value);
                $group->set($key, $value);
            }
        }

        return $group;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function indexBy($callback)
    {
        $group = new Dictionary();
        foreach ($this as $value) {

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

            $key = $callback($value);
            $group->set($key, $value);
        }

        return $group;
    }

    /**
     * {@inheritdoc}
     */
    public function reduce(callable $callback, $initial = null)
    {
        foreach ($this as $element) {

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

            $initial = $callback($initial, $element);
        }

        return $initial;
    }
}