Collections\Iterator\LazyIterableTrait

Complexity

Total Complexity

26

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	15

Importance

Changes	1
Bugs	0	Features	0

20 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

<?php

namespace Collections\Iterator;

use Collections\ArrayList;
use Collections\Immutable\ImmArrayList;
use Collections\Immutable\ImmDictionary;
use Collections\Immutable\ImmSet;
use Collections\Set;

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 ArrayList($this);
    }

    public function toImmVector()
    {
        return new ImmArrayList($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($iterable)
    {
        if (is_array($iterable)) {
            $iterable = new ImmDictionary($iterable);
        }

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

    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($iterable)
    {
        if (is_array($iterable)) {
            $iterable = new ImmDictionary($iterable);
        }

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

    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) {

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

This foreach statement is empty and can be removed.

        }

        return $v;
    }

    public function each(callable $callable)
    {
        foreach ($this as $k => $v) {

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

            $callable($v, $k);
        }

        return $this;
    }
}