Sequenceable::push() - Code Metrics - Inspection of "Update" - MBHFramework/structures - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — 1.x ( 1de473...d64718 )

by Ulises Jeremias
created 2017-12-10 18:17 UTC
Sequenceable::push() A

↳ Parent: Sequenceable
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php namespace Mbh\Collection\Traits;

use Mbh\Collection\Interfaces\Collection as CollectionInterface;
use Mbh\Collection\Interfaces\Sequenceable as SequenceableInterface;
use Mbh\Collection\FixedArray;
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;
use UnderflowException;
use OverflowException;

/**
 * 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;
        Sort::heapSorted as heapSortedWithCallback;
    }

    /**
     * @inheritDoc
     */
    public static function fromItems(Traversable $array): SequenceableInterface
    {
        // We can only do it this way if we can count it
        if ($array instanceof Countable) {
            $sfa = new SplFixedArray(count($array));

            foreach ($array as $i => $elem) {
                $sfa[$i] = $elem;
            }

            return new static($sfa);
            return /** @scrutinizer ignore-call */ new static($sfa);
        }

        // If we can't count it, it's simplest to iterate into an array first
        return static::fromArray(iterator_to_array($array));
    }

    /**
     * @inheritDoc
     */
    public static function fromArray(array $array): SequenceableInterface
    {
        return new static(SplFixedArray::fromArray($array));
        return /** @scrutinizer ignore-call */ new static(SplFixedArray::fromArray($array));
    }

    /**
     * @inheritDoc
     */
    public function copy(): CollectionInterface
    {
        return static::fromArray($this->toArray());
    }

    /**
     * @inheritDoc
     */
    public function contains(...$values): bool
    {
        foreach ($values as $value) {
            if (!$this->find($value)) {
                return false;
            }
        }

        return true;
    }

    /**
    * @inheritDoc
    */
    public function first()
    {
        if ($this->isEmpty()) {
            throw new UnderflowException();
        }

        return $this[0];
    }

    /**
     * @inheritDoc
     */
    public function get(int $index)
    {
        if (! $this->validIndex($index)) {
        if (! $this->/** @scrutinizer ignore-call */ validIndex($index)) {
            throw new OutOfRangeException();

        }

        return $this[$index];
    }

    /**
     * @inheritDoc
     */
    public function insert(int $index, ...$values)
    public function insert(int $index, /** @scrutinizer ignore-unused */ ...$values)
    {
        if (! $this->validIndex($index) && $index !== count($this)) {
        if (! $this->validIndex($index) && $index !== count(/** @scrutinizer ignore-type */ $this)) {
            throw new OutOfRangeException();
        }

        // next implementation
    }

    /**
     * @inheritDoc
     */
    public function last()
    {
        if ($this->isEmpty()) {
            throw new UnderflowException();
        }

        return $this[count($this) - 1];
        return $this[count(/** @scrutinizer ignore-type */ $this) - 1];
    }

    /**
     * @inheritDoc
     */
    public function pop()
    {
        if ($this->isEmpty()) {
            throw new UnderflowException();
        }

        // next impplementation
    }

    /**
     * Pushes all values of either an array or traversable object.
     */
    private function pushAll($values)
    {
        foreach ($values as $value) {
            $this[] = $value;
        }

        $this->checkCapacity();
               checkCapacity();
    }

    /**
     * @inheritDoc
     */
    public function push(...$values)
    {
        $this->pushAll($values);
    }

    /**
     * @inheritDoc
     */
    public function map(callable $callback): SequenceableInterface
    {
        $count = count($this);
        $count = count(/** @scrutinizer ignore-type */ $this);
        $sfa = new SplFixedArray($count);

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

        return new static($sfa);
        return /** @scrutinizer ignore-call */ new static($sfa);
    }

    /**
     * @inheritDoc
     */
    public function walk(callable $callback): SequenceableInterface
    {
        foreach ($this as $i => $elem) {
            $callback($elem, $i, $this);
        }

        return $this;

    }

    /**
     * @inheritDoc
     */
    public function filter(callable $callback): SequenceableInterface
    {
        $count = count($this);
        $count = count(/** @scrutinizer ignore-type */ $this);
        $sfa = new SplFixedArray($count);
        $newCount = 0;

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

        $sfa->setSize($newCount);
        return new static($sfa);
        return /** @scrutinizer ignore-call */ new static($sfa);
    }

    /**
     * @inheritDoc
     */
    public function reduce(callable $callback, $accumulator = null)
    {
        foreach ($this as $i => $elem) {
            $accumulator = $callback($accumulator, $elem, $i, $this);
        }

        return $accumulator;
    }

    /**
     * @inheritDoc
     */
    public function join(string $token = ',', string $secondToken = null): string
    {
        $str = "";
        if ($secondToken) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            foreach ($this as $i => $elem) {
                $str .= $token . (string) $elem . $secondToken;
            }
        } else {
            $this->rewind();
                   rewind();
            while ($this->valid()) {
            while ($this->/** @scrutinizer ignore-call */ valid()) {
                $str .= (string) $this->current();
                $str .= (string) $this->/** @scrutinizer ignore-call */ current();
                $this->next();
                       next();
                if ($this->valid()) {
                    $str .= $token;
                }
            }
        }

        return $str;
    }

    /**
     * @inheritDoc
     */
    public function slice(int $begin = 0, int $end = null): SequenceableInterface
    {
        $it = new SliceIterator($this, $begin, $end);
        $it = new SliceIterator(/** @scrutinizer ignore-type */ $this, $begin, $end);
        return new static($it);
        return /** @scrutinizer ignore-call */ new static($it);
    }

    /**
     * @inheritDoc
     */
    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);
        return /** @scrutinizer ignore-call */ new static($concatIt);
    }

    /**
     * @inheritDoc
     */
    public function find(callable $callback)
    {
        foreach ($this as $i => $elem) {
            if ($callback($elem, $i, $this)) {
                return $elem;
            }
        }
    }

    /**
     * @inheritDoc
     */
    public function sort(callable $callback = null): SequenceableInterface
    {
        if ($callback) {
            return $this->mergeSort($callback);
        }

        return $this->arraySort();
    }

    /**
     * @inheritDoc
     */
    public function sorted(callable $callback = null): SequenceableInterface
    {
        $copy = FixedArray::fromItems($this);
        $copy = FixedArray::fromItems(/** @scrutinizer ignore-type */ $this);

        if ($callback) {
            $copy->mergeSort($callback);
        }

        $copy->arraySort();

        return static::fromItems($copy);
    }

    /**
     * @inheritDoc
     */
    public function heapSorted(SplHeap $heap): SequenceableInterface
    {
        return $this->copy()->heapSort($heap);
    }

    /**
     * @inheritDoc
     */
    public function heapSort(SplHeap $heap): SequenceableInterface
    {
        foreach ($this as $item) {
            $heap->insert($item);
        }

        $this->setTraversable(static::fromItems($heap));

        return $this;

    }

    abstract protected function setTraversable(Traversable $traversable);
}

MBHFramework / structures

Push — 1.x ( 1de473...d64718 )

Sequenceable::push() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
