Collections\Iterator\LazyKeyedIterableTrait

Complexity

Total Complexity

51

Size/Duplication

Total Lines	264
Duplicated Lines	14.39 %

Coupling/Cohesion

Components	0
Dependencies	21

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	toArray()	0	9	2
A	toValuesArray()	0	9	2
A	toKeysArray()	0	9	2
A	toVector()	0	4	1
A	toImmVector()	0	4	1
A	toMap()	0	4	1
A	toImmMap()	0	4	1
A	toSet()	0	4	1
A	toImmSet()	0	4	1
A	lazy()	0	4	1
A	values()	0	4	1
A	keys()	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()	0	8	2
A	take()	0	4	1
A	takeWhile()	0	4	1
A	skip()	0	4	1
A	skipWhile()	0	4	1
A	slice()	0	4	1
A	concat()	0	8	2
A	first()	0	8	2
A	firstKey()	0	8	2
A	last()	0	8	2
A	lastKey()	0	8	2
A	each()	0	8	2
A	exists()	0	10	3
A	concatAll()	12	12	2
A	groupBy()	16	16	4
A	indexBy()	10	10	2
A	reduce()	0	8	2

<?php

namespace Collections\Iterator;

use Collections\Immutable\ImmVector;
use Collections\Immutable\ImmMap;
use Collections\Immutable\ImmSet;
use Collections\Map;
use Collections\Pair;
use Collections\Set;
use Collections\Vector;
use Collections\VectorInterface;

trait LazyKeyedIterableTrait
{
    public function toArray()
    {
        $arr = [];
        foreach ($this as $k => $v) {

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

            $arr[$k] = $v;
        }

        return $arr;
    }

    public function toValuesArray()
    {
        $arr = [];
        foreach ($this as $v) {

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

            $arr[] = $v;
        }

        return $arr;
    }

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

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

            $arr[] = $k;
        }

        return $arr;
    }

    public function toVector()
    {
        return new Vector($this);
    }

    public function toImmVector()
    {
        return new ImmVector($this);
    }

    public function toMap()
    {
        return new Map($this);
    }

    public function toImmMap()
    {
        return new ImmMap($this);
    }

    public function toSet()
    {
        return new Set($this);
    }

    public function toImmSet()
    {
        return new ImmSet($this);
    }

    public function lazy()
    {
        return $this;
    }

    public function values()
    {
        return new LazyValuesIterable($this);
    }

    public function keys()
    {
        return new LazyKeysIterable($this);
    }

    public function map(callable $callback)
    {
        return new LazyMapKeyedIterable($this, $callback);
    }

    public function mapWithKey($callback)
    {
        return new LazyMapWithKeyIterable($this, $callback);
    }

    public function filter(callable $callback)
    {
        return new LazyFilterKeyedIterable($this, $callback);
    }

    public function filterWithKey($callback)
    {
        return new LazyFilterWithKeyIterable($this, $callback);
    }

    public function zip($traversable)
    {
        if (is_array($traversable)) {
            $traversable = new ImmMap($traversable);
        }

        return new LazyZipKeyedIterable($this, $traversable);
    }

    public function take($size = 1)
    {
        return new LazyTakeKeyedIterable($this, $size);
    }

    public function takeWhile($fn)
    {
        return new LazyTakeWhileKeyedIterable($this, $fn);
    }

    public function skip($n)
    {
        return new LazySkipKeyedIterable($this, $n);
    }

    public function skipWhile($fn)
    {
        return new LazySkipWhileKeyedIterable($this, $fn);
    }

    public function slice($start, $len)
    {
        return new LazySliceKeyedIterable($this, $start, $len);
    }

    public function concat($Enumerable)
    {
        if (is_array($Enumerable)) {
            $Enumerable = new ImmMap($Enumerable);
        }

        return new LazyConcatIterable($this, $Enumerable);
    }

    public function first()
    {
        foreach ($this as $v) {

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

            return $v;
        }

        return null;
    }

    public function firstKey()
    {
        foreach ($this as $k => $_) {

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

            return $k;
        }

        return null;
    }

    public function last()
    {
        $v = null;
        foreach ($this as $v) {

This foreach statement is empty and can be removed.

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

        }

        return $v;
    }

    public function lastKey()
    {
        $k = null;
        foreach ($this as $k => $_) {

This foreach statement is empty and can be removed.

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

        }

        return $k;
    }

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

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

            $callable($v);
        }

        return $this;
    }

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

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> 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 ($subArray) use ($results) {
            foreach ($subArray as $item) {
                $results->add($item);
            }
        });

        return $results;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function groupBy($callback)

This method seems to be duplicated in your project.

    {
        $group = new Map();
        foreach ($this as $value) {

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> is not traversable.

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

The call to LazyKeyedIterableTrait::__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)

This method seems to be duplicated in your project.

    {
        $group = new Map();
        foreach ($this as $value) {

The expression $this of type this<Collections\Iterator\LazyKeyedIterableTrait> 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\Iterator\LazyKeyedIterableTrait> is not traversable.

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

        return $initial;
    }
}