StreamTrait::map() - Code Metrics - b2pweb/bdf-collections - Measure and Improve Code Quality continuously with Scrutinizer

StreamTrait::map() A
last analyzed 2023-01-04 13:50 UTC

↳ Parent: StreamTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Bdf\Collection\Stream;

use Bdf\Collection\HashSet;
use Bdf\Collection\Stream\Accumulator\AccumulatorInterface;
use Bdf\Collection\Stream\Collector\CollectorInterface;
use Bdf\Collection\Util\Optional;
use Bdf\Collection\Util\OptionalInterface;
use function iterator_to_array;

/**
 * Implementation of base stream methods
 *
 * @psalm-suppress LessSpecificImplementedReturnType
 */
trait StreamTrait
{
    /**
     * @see StreamInterface::filter()
     */
    public function filter(callable $predicate): StreamInterface
    {
        return new FilterStream($this, $predicate);
        return new FilterStream(/** @scrutinizer ignore-type */ $this, $predicate);
    }

    /**
     * @see StreamInterface::map()
     */
    public function map(callable $transformer): StreamInterface
    {
        return new MapStream($this, $transformer);
        return new MapStream(/** @scrutinizer ignore-type */ $this, $transformer);
    }

    /**
     * @see StreamInterface::mapKey()
     */
    public function mapKey(callable $function): StreamInterface
    {
        return new MapKeyStream($this, $function);
        return new MapKeyStream(/** @scrutinizer ignore-type */ $this, $function);
    }

    /**
     * @see StreamInterface::distinct()
     */
    public function distinct(callable $hashFunction = null): StreamInterface
    {
        return new DistinctStream($this, new HashSet($hashFunction));
        return new DistinctStream(/** @scrutinizer ignore-type */ $this, new HashSet($hashFunction));
    }

    /**
     * @see StreamInterface::sort()
     */
    public function sort(callable $comparator = null, bool $preserveKeys = false): StreamInterface
    {
        return new SortStream($this, $comparator, $preserveKeys);
        return new SortStream(/** @scrutinizer ignore-type */ $this, $comparator, $preserveKeys);
    }

    /**
     * @see StreamInterface::concat()
     */
    public function concat(StreamInterface $stream, bool $preserveKeys = true): StreamInterface
    {
        return new ConcatStream([$this, $stream], $preserveKeys);
    }

    /**
     * @see StreamInterface::flatMap()
     */
    public function flatMap(callable $transformer, bool $preserveKeys = false): StreamInterface
    {
        return new FlatMapStream($this, $transformer, $preserveKeys);
        return new FlatMapStream(/** @scrutinizer ignore-type */ $this, $transformer, $preserveKeys);
    }

    /**
     * @see StreamInterface::skip()
     */
    public function skip(int $count): StreamInterface
    {
        return new LimitStream($this, $count);
        return new LimitStream(/** @scrutinizer ignore-type */ $this, $count);
    }

    /**
     * @see StreamInterface::limit()
     */
    public function limit(int $count, int $offset = 0): StreamInterface
    {
        return new LimitStream($this, $offset, $count);
        return new LimitStream(/** @scrutinizer ignore-type */ $this, $offset, $count);
    }

    /**
     * @see StreamInterface::forEach()
     */
    public function forEach(callable $consumer): void
    {
        foreach ($this as $key => $value) {
            $consumer($value, $key);
        }
    }

    /**
     * @see StreamInterface::toArray()
     */
    public function toArray(bool $preserveKeys = true): array
    {
        return iterator_to_array($this, $preserveKeys);
        return iterator_to_array(/** @scrutinizer ignore-type */ $this, $preserveKeys);
    }

    /**
     * @see StreamInterface::first()
     */
    public function first(): OptionalInterface
    {
        foreach ($this as $value) {
            return Optional::nullable($value);
        }

        return Optional::empty();
    }

    /**
     * @see StreamInterface::reduce()
     * @psalm-suppress MissingParamType
     */
    public function reduce(callable $accumulator, $initial = null)
    {
        $carry = $initial === null && $accumulator instanceof AccumulatorInterface
            ? $accumulator->initial()
            : $initial
        ;

        foreach ($this as $item) {
            $carry = $accumulator($carry, $item);
        }

        return $carry;
    }

    /**
     * @see StreamInterface::collect()
     */
    public function collect(CollectorInterface $collector)
    {
        foreach ($this as $key => $item) {
            $collector->aggregate($item, $key);
        }

        return $collector->finalize();
    }

    /**
     * @see StreamInterface::matchAll()
     */
    public function matchAll(callable $predicate): bool
    {
        foreach ($this as $key => $item) {
            if (!$predicate($item, $key)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @see StreamInterface::matchOne()
     */
    public function matchOne(callable $predicate): bool
    {
        foreach ($this as $key => $item) {
            if ($predicate($item, $key)) {
                return true;
            }
        }

        return false;
    }
}


b2pweb / bdf-collections

StreamTrait::map() A last analyzed 2023-01-04 13:50 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

StreamTrait::map() A
last analyzed 2023-01-04 13:50 UTC