Mbh\Collection\Traits\Sequenceable

Complexity

Total Complexity

48

Size/Duplication

Total Lines	255
Duplicated Lines	0 %

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	first()	0	7	2
A	copy()	0	3	1
A	fromArray()	0	3	1
A	get()	0	7	2
A	contains()	0	9	3
A	fromItems()	0	15	3
A	insert()	0	4	3
A	clear()	0	3	1
A	setTraversable()	0	3	1
A	getSize()	0	3	1
A	push()	0	3	1
A	offsetSet()	0	6	4
A	offsetExists()	0	5	3
A	next()	0	3	1
A	toArray()	0	3	1
A	getMainTraversable()	0	3	1
A	setSize()	0	3	1
A	offsetGet()	0	3	1
A	rewind()	0	3	1
A	last()	0	7	2
A	validIndex()	0	3	2
A	pushAll()	0	9	2
A	valid()	0	3	1
A	offsetUnset()	0	5	3
A	pop()	0	12	2
A	current()	0	3	1
A	count()	0	3	1
A	key()	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\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 OutOfRangeException;

/**
 * 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
{
    protected $sfa = null;

    /**
     * Create an fixed array
     *
     * @param Traversable $array data
     */
    protected function __construct(Traversable $array)
    {
        $this->sfa = $array;
    }

    /**
     * @inheritDoc
     */
    public static function fromItems(Traversable $array)
    {
        // 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);
        }

        // 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)
    {
        return new static(SplFixedArray::fromArray($array));
    }

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

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

                return false;
            }
        }

        return true;
    }

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

    /**
    * @inheritDoc
    */
    public function first()
    {
        if ($this->isEmpty()) {

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

            throw new UnderflowException();
        }

        return $this[0];
    }

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

        return $this[$index];
    }

    /**
     * @inheritDoc
     */
    public function insert(int $index, ...$values)

The parameter $values is not used and could be removed.

    {
        if (! $this->validIndex($index) && $index !== count($this)) {

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

            throw new OutOfRangeException();
        }

        // array_splice($this->array, $index, 0, $values);
    }

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

        return $this[count($this) - 1];

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

    }

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

        $value = $this->last();
        unset($this[count($this) - 1]);

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

        $this->checkCapacity();

        return $value;
    }


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

        $this->checkCapacity();
    }

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

    public function toArray(): array
    {
        return $this->sfa->toArray();
    }

    protected function validIndex(int $index)
    {
        return $index >= 0 && $index < $this->getSize();
    }

    /**
     * Countable
     */
    public function count(): int
    {
        return count($this->sfa);
    }

    /**
     * Iterator
     */
    public function current()
    {
        return $this->sfa->current();
    }

    public function key(): int
    {
        return $this->sfa->key();
    }

    public function next()
    {
        return $this->sfa->next();
    }

    public function rewind()
    {
        return $this->sfa->rewind();
    }

    public function valid()
    {
        return $this->sfa->valid();
    }

    /**
     * ArrayAccess
     */
    public function offsetExists($offset): bool
    {
        return is_integer($offset)
            && $this->validIndex($offset)
            && $this->sfa->offsetExists($offset);
    }

    public function offsetGet($offset)
    {
        return $this->sfa->offsetGet($offset);
    }

    public function offsetSet($offset, $value)
    {
        if ($offset === null) {
            $this->push($value);
        } elseif (is_integer($offset) && $this->validIndex($offset)) {
            $this->sfa->offsetSet($offset, $value);
        }
    }

    public function offsetUnset($offset)
    {
        return is_integer($offset)
            && $this->validIndex($offset)
            && $this->sfa->offsetUnset($offset);
    }

    public function clear()
    {
        return $this->sfa->clear();
    }

    protected function getMainTraversable(): Traversable
    {
        return $this->sfa;
    }

    protected function setTraversable(Traversable $traversable)
    {
        $this->sfa = $traversable;
    }

    public function getSize(): int
    {
        return $this->sfa->getSize();
    }

    public function setSize(int $size): bool
    {
        return $this->sfa->setSize($size);
    }

    abstract protected function checkCapacity();
}