WS\Utils\Collections\AbstractCollection

Complexity

Total Complexity

20

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

96%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	of()	0	3	2
A	toArray()	0	3	1
A	getElements()	0	3	1
A	merge()	0	3	1
A	size()	0	3	1
A	setElements()	0	5	1
A	addAll()	0	13	3
A	add()	0	9	2
A	equals()	0	3	1
A	clear()	0	3	1
A	contains()	0	3	1
A	isEmpty()	0	3	1
A	copy()	0	3	1
A	getIterator()	0	3	1

<?php
/**
 * @author Maxim Sokolovsky
 */

namespace WS\Utils\Collections;

abstract class AbstractCollection implements Collection
{
    protected $elements = [];
    protected $pointer = -1;

    public function __construct(?array $elements = null)
    {
        if ($elements === null) {
            return;
        }
        $this->setElements($elements);
    }

    public static function of(...$elements): self
    {
        return new static($elements ?: null);
    }

    public function add($element): bool
    {
        if ($this->pointer === PHP_INT_MAX) {
            return false;
        }
        $this->pointer++;
        $this->elements[] = $element;
        $this->afterElementAdd($element);
        return true;
    }

    public function addAll(iterable $elements): bool
    {
        foreach ($elements as $element) {
            $this->elements[] = $element;
            $this->afterElementAdd($element);
        }
        $newPointer = count($this->elements) - 1;
        if ($newPointer > PHP_INT_MAX) {
            $this->elements = array_slice($this->elements, 0, $this->pointer);
        } else {
            $this->pointer = $newPointer;
        }
        return true;
    }

    public function merge(Collection $collection): bool
    {
        return $this->addAll($collection->toArray());
    }

    public function clear(): void
    {
        $this->setElements([]);
    }

    public function contains($element): bool
    {
        return in_array($element, $this->elements, true);
    }

    public function equals(Collection $collection): bool
    {
        return $this->toArray() === $collection->toArray();
    }

    public function size(): int
    {
        return $this->pointer + 1;
    }

    public function isEmpty(): bool
    {
        return $this->pointer === -1;
    }

    public function toArray(): array
    {
        return $this->elements;
    }

    public function getIterator()
    {
        yield from $this->toArray();
    }

    public function copy(): Collection
    {
        return clone $this;
    }

    protected function setElements(array $elements): void
    {
        $this->elements = array_values($elements);
        $this->pointer = count($elements) - 1;
        $this->afterElementsSet();
    }

    protected function getElements(): array
    {
        return $this->elements;
    }

    abstract protected function afterElementAdd($element): void;

    abstract protected function afterElementsSet(): void;

    abstract public function stream(): Stream;
}