SortStream::forEach() - Code Metrics - Inspection of "Add build for php 8" - b2pweb/bdf-collections - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 987e4b...4b05d5 )

by Vincent

created 2021-12-15 10:59 UTC

SortStream::forEach() A

↳ Parent: SortStream

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	3
nc	2
nop	1
dl	0
loc	4
ccs	3
cts	3
cp	1
crap	2
rs	10
c	1
b	0
f	0

<?php

namespace Bdf\Collection\Stream;

use Bdf\Collection\Util\Optional;
use Bdf\Collection\Util\OptionalInterface;
use Iterator;
use function asort;
use function current;
use function key;
use function next;
use function reset;
use function sort;
use function uasort;
use function usort;

/**
 * Implementation of StreamInterface::sort() return value
 *
 * @template T
 *
 * @implements StreamInterface<T, array-key>
 * @implements Iterator<array-key, T>
 *
 * @internal
 */
final class SortStream implements Iterator, StreamInterface
{
    use StreamTrait;

    /**
     * @var StreamInterface<T, mixed>
     */
    private $stream;

    /**
     * @var callable(T,T):int|null
     */
    private $comparator;

    /**
     * @var bool
     */
    private $preserveKeys;

    /**
     * @var T[]|null
     */
    private $data = null;


    /**
     * SortStream constructor.
     *
     * @param StreamInterface<T, mixed> $stream
     * @param callable(T,T):int|null $comparator
     * @param bool $preserveKeys
     */
    public function __construct(StreamInterface $stream, ?callable $comparator = null, bool $preserveKeys = true)
    {
        $this->stream = $stream;
        $this->comparator = $comparator;
        $this->preserveKeys = $preserveKeys;
    }

    /**
     * {@inheritdoc}
     *
     * @psalm-assert !null $this->data
     * @psalm-suppress InvalidReturnType
     */
    public function toArray(bool $preserveKeys = true): array
    {
        if ($this->data === null) {
            $this->buildData();
        }

        // Built data keep keys, but toArray() request without keys
        // So call array_values to remove keys
        if (!$preserveKeys && $this->preserveKeys) {
            return array_values($this->data);
            return array_values(/** @scrutinizer ignore-type */ $this->data);
        }

        return $this->data;

    }

    /**
     * {@inheritdoc}
     */
    public function forEach(callable $consumer): void
    {
        foreach ($this->toArray() as $k => $v) {
            $consumer($v, $k);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function first(): OptionalInterface
    {
        $empty = true;
        $min = null;

        foreach ($this->stream as $value) {
            if ($empty) {
                $min = $value;
                $empty = false;
            } else {
                if ($this->comparator === null) {
                    if ($value < $min) {
                        $min = $value;
                    }
                } elseif (($this->comparator)($value, $min) < 0) {
                    $min = $value;
                }
            }
        }

        return Optional::nullable($min);
    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        if ($this->data === null) {
            $this->buildData();
        }

        return current($this->data);
        return current(/** @scrutinizer ignore-type */ $this->data);
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        if ($this->data === null) {
            $this->buildData();
        }

        next($this->data);
        next(/** @scrutinizer ignore-type */ $this->data);
    }

    /**
     * {@inheritdoc}
     */
    public function key()
    {
        if ($this->data === null) {
            $this->buildData();
        }

        return key($this->data);
        return key(/** @scrutinizer ignore-type */ $this->data);
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        if ($this->data === null) {
            $this->buildData();
        }

        return key($this->data) !== null;
        return key(/** @scrutinizer ignore-type */ $this->data) !== null;
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        if ($this->data === null) {
            $this->buildData();
        }

        reset($this->data);
        reset(/** @scrutinizer ignore-type */ $this->data);
    }

    /**
     * Build the inner sorted data array
     *
     * @psalm-assert !null $this->data
     */
    private function buildData(): void
    {
        $data = $this->stream->toArray($this->preserveKeys);

        if ($this->comparator) {
            if ($this->preserveKeys) {
                uasort($data, $this->comparator);
            } else {
                usort($data, $this->comparator);
            }
        } elseif($this->preserveKeys) {
            asort($data);
        } else {
            sort($data);
        }

        $this->data = $data;
    }
}


b2pweb / bdf-collections

Push — master ( 987e4b...4b05d5 )

SortStream::forEach() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like