F500\Equatable\EquatableVector

Complexity

Total Complexity

40

Size/Duplication

Total Lines	227
Duplicated Lines	43.61 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	10	10	3
A	__clone()	0	10	2
A	add()	0	8	1
A	remove()	9	9	1
A	replace()	0	12	2
A	get()	0	8	2
A	search()	10	10	3
A	searchAll()	16	16	4
A	contains()	0	9	2
A	containsIndex()	0	4	1
B	equals()	18	18	5
A	count()	0	4	1
A	countItem()	12	12	3
A	intersect()	12	12	3
A	diff()	12	12	3
A	filter()	0	6	1
A	map()	0	6	1
A	reduce()	0	4	1
A	getIterator()	0	4	1

<?php

/**
 * @license https://github.com/f500/equatable/blob/master/LICENSE MIT
 */

declare(strict_types=1);

namespace F500\Equatable;

use ArrayIterator;
use Countable;
use IteratorAggregate;
use Traversable;

/**
 * @copyright Copyright (c) 2015 Future500 B.V.
 * @author    Jasper N. Brouwer <jasper@future500.nl>
 */
final class EquatableVector implements Equatable, Countable, IteratorAggregate
{
    /**
     * @var Equatable[]
     */
    private $items = [];

    /**
     * @param Equatable[] $items
     */
    public function __construct(array $items = [])
    {
        foreach ($items as $item) {
            if (!$item instanceof Equatable) {
                throw InvalidArgumentException::invalidTypeInArray('items', Equatable::class, $item);
            }

            $this->items[] = $item;
        }
    }

    public function __clone()

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $item) {
            $items[] = clone $item;
        }

        $this->items = $items;
    }

    public function add(Equatable $value): EquatableVector
    {
        $items = $this->items;

        $items[] = $value;

        return new static($items);
    }

    public function remove(Equatable $value): EquatableVector

This method seems to be duplicated in your project.

    {
        $index = $this->search($value);
        $items = $this->items;

        unset($items[$index]);

        return new static($items);
    }

    public function replace(int $index, Equatable $value): EquatableVector
    {
        if (!$this->containsIndex($index)) {
            throw OutOfRangeException::indexOutOfRange($index);
        }

        $items = $this->items;

        $items[$index] = $value;

        return new static($items);
    }

    public function get(int $index): Equatable
    {
        if (!$this->containsIndex($index)) {
            throw OutOfRangeException::indexOutOfRange($index);
        }

        return $this->items[$index];
    }

    public function search(Equatable $value): int

This method seems to be duplicated in your project.

    {
        foreach ($this->items as $index => $item) {
            if ($item->equals($value)) {
                return $index;
            }
        }

        throw OutOfRangeException::valueOutOfRange($value);
    }

    public function searchAll(Equatable $value): array

This method seems to be duplicated in your project.

    {
        $foundIndexes = [];

        foreach ($this->items as $index => $item) {
            if ($item->equals($value)) {
                $foundIndexes[] = $index;
            }
        }

        if (!$foundIndexes) {

The expression $foundIndexes of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw OutOfRangeException::valueOutOfRange($value);
        }

        return $foundIndexes;
    }

    public function contains(Equatable $value): bool
    {
        try {
            $this->search($value);
            return true;
        } catch (OutOfRangeException $e) {
            return false;
        }
    }

    public function containsIndex(int $index): bool
    {
        return isset($this->items[$index]);
    }

    public function equals($other): bool

This method seems to be duplicated in your project.

    {
        if (!$other instanceof static) {
            return false;
        }

        if ($this->count() !== $other->count()) {
            return false;
        }

        foreach ($this->items as $item) {
            if ($this->countItem($item) !== $other->countItem($item)) {
                return false;
            }
        }

        return true;
    }

    public function count(): int
    {
        return count($this->items);
    }

    public function countItem(Equatable $value): int

This method seems to be duplicated in your project.

    {
        $count = 0;

        foreach ($this->items as $item) {
            if ($item->equals($value)) {
                $count++;
            }
        }

        return $count;
    }

    public function intersect(self $other): self

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $item) {
            if ($other->contains($item)) {
                $items[] = $item;
            }
        }

        return new self($items);
    }

    public function diff(self $other): self

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $item) {
            if (!$other->contains($item)) {
                $items[] = $item;
            }
        }

        return new self($items);
    }

    /**
     * The filter callable is given an equatable item, and should return
     * a boolean indicating whether the item remains or not.
     *
     * function (Equatable $item): bool {
     *     return true;
     * }
     */
    public function filter(callable $filter): self
    {
        return new self(
            array_filter($this->items, $filter)
        );
    }

    /**
     * The mapper callable is given an equatable item, and should return
     * a new value to use in it's place.
     *
     * function (Equatable $item) {
     *     return $item;
     * }
     */
    public function map(callable $mapper): self
    {
        return new self(
            array_map($mapper, $this->items)
        );
    }

    /**
     * The reducer callable is given the carry value and an equatable item,
     * and should return the value it should be reduced to.
     *
     * function ($carry, Equatable $item) {
     *     return $carry + 1;
     * }
     */
    public function reduce(callable $reducer, $initial = null)
    {
        return array_reduce($this->items, $reducer, $initial);
    }

    public function getIterator(): Traversable
    {
        return new ArrayIterator($this->items);
    }
}