Mbh\Collection\Traits\Sequenceable

Complexity

Total Complexity

24

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	reduce()	0	7	2
B	join()	0	19	5
A	slice()	0	4	1
A	find()	0	5	3
A	walk()	0	7	2
A	concat()	0	11	1
A	map()	0	10	2
A	heapSort()	0	6	2
A	filter()	0	14	3
A	sort()	0	7	2
A	copy()	0	3	1

<?php namespace Mbh\Collection\Traits;

use Mbh\Collection\Interfaces\Collection as CollectionInterface;
use Mbh\Collection\Interfaces\Sequenceable as SequenceableInterface;
use Mbh\Collection\CallbackHeap;
use Mbh\Iterator\SliceIterator;
use Mbh\Iterator\ConcatIterator;
use SplFixedArray;
use SplHeap;
use SplStack;
use LimitIterator;
use Iterator;
use ArrayAccess;
use Countable;
use CallbackFilterIterator;
use JsonSerializable;
use RuntimeException;
use Traversable;
use ReflectionClass;

/**
 * MBHFramework
 *
 * @link      https://github.com/MBHFramework/mbh-framework
 * @copyright Copyright (c) 2017 Ulises Jeremias Cornejo Fandos
 * @license   https://github.com/MBHFramework/mbh-framework/blob/master/LICENSE (MIT License)
 */

trait Sequenceable
{
    use Collection;
    use Sort {
        Sort::heapSort as heapSortWithCallback;
    }

    /**
     * Map elements to a new Sequenceable via a callback
     *
     * @param callable $callback Function to map new data
     * @return Sequenceable
     */
    public function map(callable $callback): SequenceableInterface
    {
        $count = count($this);

$this of type Mbh\Collection\Traits\Sequenceable is incompatible with the type Countable|array expected by parameter $var of count().

        $sfa = new SplFixedArray($count);

        for ($i = 0; $i < $count; $i++) {
            $sfa[$i] = $callback($this[$i], $i, $this);
        }

        return new static($sfa);

The call to Mbh\Collection\Traits\Sequenceable::__construct() has too many arguments starting with $sfa.

The expression return new static($sfa) returns the type Mbh\Collection\Traits\Sequenceable which is incompatible with the type-hinted return Mbh\Collection\Interfaces\Sequenceable.

    }

    /**
     * forEach, or "walk" the data
     * Exists primarily to provide a consistent interface, though it's seldom
     * any better than a simple php foreach. Mainly useful for chaining.
     * Named walk for historic reasons - forEach is reserved in PHP
     *
     * @param callable $callback Function to call on each element
     * @return Sequenceable
     */
    public function walk(callable $callback): SequenceableInterface
    {
        foreach ($this as $i => $elem) {
            $callback($elem, $i, $this);
        }

        return $this;

The expression return $this returns the type Mbh\Collection\Traits\Sequenceable which is incompatible with the type-hinted return Mbh\Collection\Interfaces\Sequenceable.

    }

    /**
     * Filter out elements
     *
     * @param callable $callback Function to filter out on false
     * @return Sequenceable
     */
    public function filter(callable $callback): SequenceableInterface
    {
        $count = count($this);

$this of type Mbh\Collection\Traits\Sequenceable is incompatible with the type Countable|array expected by parameter $var of count().

        $sfa = new SplFixedArray($count);
        $newCount = 0;

        foreach ($this as $elem) {
            if ($callback($elem)) {
                $sfa[$newCount++] = $elem;
            }
        }

        $sfa->setSize($newCount);
        return new static($sfa);

The call to Mbh\Collection\Traits\Sequenceable::__construct() has too many arguments starting with $sfa.

The expression return new static($sfa) returns the type Mbh\Collection\Traits\Sequenceable which is incompatible with the type-hinted return Mbh\Collection\Interfaces\Sequenceable.

    }

    /**
     * Reduce to a single value
     *
     * @param callable $callback Callback(
     *     mixed $previous, mixed $current[, mixed $index, mixed $immArray]
     * ):mixed Callback to run reducing function
     * @param mixed $accumulator Initial value for first argument
     */
    public function reduce(callable $callback, $accumulator = null)
    {
        foreach ($this as $i => $elem) {
            $accumulator = $callback($accumulator, $elem, $i, $this);
        }

        return $accumulator;
    }

    /**
     * Join a set of strings together.
     *
     * @param string $token Main token to put between elements
     * @param string $secondToken If set, $token on left $secondToken on right
     * @return string
     */
    public function join(string $token = ',', string $secondToken = null): string
    {
        $str = "";
        if ($secondToken) {

The expression $secondToken of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            foreach ($this as $i => $elem) {
                $str .= $token . (string) $elem . $secondToken;
            }
        } else {
            $this->rewind();

It seems like rewind() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            while ($this->valid()) {

It seems like valid() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $str .= (string) $this->current();

It seems like current() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $this->next();

It seems like next() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                if ($this->valid()) {
                    $str .= $token;
                }
            }
        }

        return $str;
    }

    /**
     * Take a slice of the array
     *
     * @param int $begin Start index of slice
     * @param int $end End index of slice
     * @return Sequenceable
     */
    public function slice(int $begin = 0, int $end = null): SequenceableInterface
    {
        $it = new SliceIterator($this, $begin, $end);

$this of type Mbh\Collection\Traits\Sequenceable is incompatible with the type Iterator expected by parameter $iterator of Mbh\Iterator\SliceIterator::__construct().

        return new static($it);

The call to Mbh\Collection\Traits\Sequenceable::__construct() has too many arguments starting with $it.

The expression return new static($it) returns the type Mbh\Collection\Traits\Sequenceable which is incompatible with the type-hinted return Mbh\Collection\Interfaces\Sequenceable.

    }

    /**
     * Concat to the end of this array
     *
     * @param Traversable,...
     * @return Sequenceable
     */
    public function concat(): SequenceableInterface
    {
        $args = func_get_args();
        array_unshift($args, $this);

        // Concat this iterator, and variadic args
        $class = new ReflectionClass('Mbh\Iterator\ConcatIterator');
        $concatIt = $class->newInstanceArgs($args);

        // Create as new immutable's iterator
        return new static($concatIt);

The call to Mbh\Collection\Traits\Sequenceable::__construct() has too many arguments starting with $concatIt.

The expression return new static($concatIt) returns the type Mbh\Collection\Traits\Sequenceable which is incompatible with the type-hinted return Mbh\Collection\Interfaces\Sequenceable.

    }

    /**
     * Find a single element
     *
     * @param callable $callback The test to run on each element
     * @return mixed The element we found
     */
    public function find(callable $callback)
    {
        foreach ($this as $i => $elem) {
            if ($callback($elem, $i, $this)) {
                return $elem;
            }
        }
    }

    /**
     * Return a new sorted Sequenceable
     *
     * @param callable $callback The sort callback
     * @return Sequenceable
     */
    public function sort(callable $callback = null)
    {
        if ($callback) {
            return $this->mergeSort($callback);
        }

        return $this->arraySort();
    }

    /**
     * Sort a new Sequenceable by filtering through a heap.
     * Tends to run much faster than array or merge sorts, since you're only
     * sorting the pointers, and the sort function is running in a highly
     * optimized space.
     *
     * @param SplHeap $heap The heap to run for sorting
     * @return Sequenceable
     */
    public function heapSort(SplHeap $heap): SequenceableInterface
    {
        foreach ($this as $item) {
            $heap->insert($item);
        }
        return static::fromItems($heap);
    }

    /**
     * Creates a shallow copy of the collection.
     *
     * @return CollectionInterface a shallow copy of the collection.
     */
    public function copy(): CollectionInterface
    {
        return static::fromArray($this->toArray());
    }
}