Collections\Iterator\LazyIterableTrait

Complexity

Total Complexity

39

Size/Duplication

Total Lines	206
Duplicated Lines	12.62 %

Coupling/Cohesion

Components	0
Dependencies	18

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	toArray()	0	9	2
A	toValuesArray()	0	4	1
A	toVector()	0	4	1
A	toImmVector()	0	4	1
A	toSet()	0	4	1
A	toImmSet()	0	4	1
A	lazy()	0	4	1
A	values()	0	4	1
A	map()	0	4	1
A	filter()	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	last()	0	8	2
A	each()	0	8	2
A	exists()	0	10	3
A	concatAll()	0	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 LazyIterableTrait
{
    public function toArray()
    {
        $arr = array();
        foreach ($this as $v) {

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

            $arr[] = $v;
        }

        return $arr;
    }

    public function toValuesArray()
    {
        return $this->toArray();
    }

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

    public function toImmVector()
    {
        return new ImmVector($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 map(callable $callback)
    {
        return new LazyMapIterable($this, $callback);
    }

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

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

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

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

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

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

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

    public function slice($start, $len)
    {
        return new LazySliceIterable($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\LazyIterableTrait> is not traversable.

            return $v;
        }

        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\LazyIterableTrait> is not traversable.

        }

        return $v;
    }

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

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

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

        return false;
    }

    public function concatAll()
    {
        /** @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\LazyIterableTrait> is not traversable.

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

The call to LazyIterableTrait::__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\LazyIterableTrait> 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\LazyIterableTrait> is not traversable.

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

        return $initial;
    }
}