FixedArray::arraySort() - Code Metrics - Inspection of "Array sorted method fix" - MBHFramework/structures - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.x ( 5399bc...5b3b89 )

by Ulises Jeremias

created 2017-12-05 14:32 UTC

FixedArray::arraySort() A

↳ Parent: FixedArray

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	0
loc	13
rs	9.4285
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\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;

/**
 * The Fixed Array
 *
 * A FixedArray is a sequence of values in a contiguous buffer that grows and
 * shrinks automatically. It’s the most efficient sequential structure because
 * a value’s index is a direct mapping to its index in the buffer, and the
 * growth factor isn't bound to a specific multiple or exponent.
 *
 * @package structures
 * @author Ulises Jeremias Cornejo Fandos <[email protected]>
 */

class FixedArray implements SequenceableInterface
{
    use Traits\Sequenceable;

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

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

    /**
     * Fallback behaviour to use the builtin array sort functions
     *
     * @param callable $callback The callback for comparison
     * @return SequenceableInterface
     */
    public function arraySort(callable $callback = null): SequenceableInterface
    {
        $array = $this->toArray();

        if ($callback) {
            usort($array, $callback);
        } else {
            sort($array);
        }

        $this->sfa = static::fromArray($array);

        return $this;
    }

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

    private function validIndex(int $index)
    {
        return $index >= 0 && $index < count($this);
    }

    /**
     * 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 is_integer($offset)
            && $this->validIndex($offset)
            && $this->sfa->offsetExists($offset);
            && $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)
    {
        return is_integer($offset)
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
            && $this->validIndex($offset)
            && $this->sfa->offsetSet($offset, $value);
            && $this->sfa->/** @scrutinizer ignore-call */ offsetSet($offset, $value);
    }

    public function offsetUnset($offset)
    {
        return is_integer($offset)
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
            && $this->validIndex($offset)
            && $this->sfa->offsetUnset($offset);
            && $this->sfa->/** @scrutinizer ignore-call */ offsetUnset($offset);
    }

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


MBHFramework / structures

Push — 1.x ( 5399bc...5b3b89 )

FixedArray::arraySort() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like