ImmutableArray::fromArray() - Code Metrics - Inspection of "Sequenceable trait added" - MBHFramework/structures - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.x ( 3cc805...d95d50 )

by Ulises Jeremias

created 2017-12-03 23:23 UTC

ImmutableArray::fromArray() A

↳ Parent: ImmutableArray

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;

/**
 * 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)
 */

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;

/**
 * The Immutable Array
 *
 * This provides special methods for quickly creating an immutable array,
 * either from any Traversable, or using a C-optimized fromArray() to directly
 * instantiate from. Also includes methods fundamental to functional
 * programming, e.g. map, filter, join, and sort.
 *
 * @package structures
 * @author Ulises Jeremias Cornejo Fandos <[email protected]>
 */

class ImmutableArray implements SequenceableInterface
{
    use Traits\Sequenceable;

    // The secondary flash array - fixed array
    private $sfa = null;

    /**
     * Create an immutable array
     *
     * @param Traversable $immute Data guaranteed to be immutable
     */
    private function __construct(Traversable $immute)
    {
        $this->sfa = $immute;
    }

    /**
     * Factory for building ImmutableArrays from any traversable
     *
     * @return ImmutableArray
     */
    public static function fromItems(Traversable $array): self
    {
        // 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));
    }

    /**
     * Build from an array
     *
     * @return ImmutableArray
     */
    public static function fromArray(array $array): self
    {
        return new static(SplFixedArray::fromArray($array));
    }

    public function toArray(): array
    {
        return $this->sfa->toArray();
        return $this->sfa->/** @scrutinizer ignore-call */ toArray();
    }

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

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

    public function key(): int
    {
        return $this->sfa->key();
        return $this->sfa->/** @scrutinizer ignore-call */ key();
    }

    public function next()
    {
        return $this->sfa->next();
        return $this->sfa->/** @scrutinizer ignore-call */ next();
    }

    public function rewind()
    {
        return $this->sfa->rewind();
        return $this->sfa->/** @scrutinizer ignore-call */ rewind();
    }

    public function valid()
    {
        return $this->sfa->valid();
        return $this->sfa->/** @scrutinizer ignore-call */ valid();
    }

    /**
     * ArrayAccess
     */
    public function offsetExists($offset): bool
    {
        return $this->sfa->offsetExists($offset);
        return $this->sfa->/** @scrutinizer ignore-call */ offsetExists($offset);
    }

    public function offsetGet($offset)
    {
        return $this->sfa->offsetGet($offset);
        return $this->sfa->/** @scrutinizer ignore-call */ offsetGet($offset);
    }

    public function offsetSet($offset, $value)
    {
        throw new RuntimeException('Attempt to mutate immutable ' . __CLASS__ . ' object.');
    }

    public function offsetUnset($offset)
    {
        throw new RuntimeException('Attempt to mutate immutable ' . __CLASS__ . ' object.');
    }

    public function clear()
    {
        throw new RuntimeException('Attempt to mutate immutable ' . __CLASS__ . ' object.');
    }
}


MBHFramework / structures

Push — 1.x ( 3cc805...d95d50 )

ImmutableArray::fromArray() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like