Barenote\Collection\ArrayCollection

Complexity

Total Complexity

28

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	isEmpty()	0	4	1
A	first()	0	4	1
A	firstOrNull()	0	7	2
A	add()	0	4	1
A	clear()	0	4	1
A	contains()	0	4	1
A	getIterator()	0	4	1
A	offsetExists()	0	4	1
A	containsKey()	0	4	2
A	offsetGet()	0	4	1
A	get()	0	8	2
A	offsetSet()	0	4	1
A	set()	0	4	1
A	offsetUnset()	0	4	1
A	remove()	0	11	3
A	count()	0	4	1
A	jsonSerialize()	0	4	1
A	toArray()	0	4	1
A	filter()	0	4	1
A	extractProperties()	0	11	1
A	forAll()	0	6	2

<?php
namespace Barenote\Collection;

use ArrayIterator;
use Closure;

/**
 * Class ArrayCollection
 * @package Barenote\Collection
 */
class ArrayCollection implements \Countable, \IteratorAggregate, \ArrayAccess, \JsonSerializable
{
    /**
     * @var array
     */
    private $elements;

    /**
     * ArrayCollection constructor.
     * @param array $elements
     */
    public function __construct(array $elements = [])
    {
        $this->elements = $elements;
    }

    public function isEmpty()
    {
        return count($this->elements) == 0;
    }

    public function first()
    {
        return reset($this->elements);
    }
    public function firstOrNull()
    {
        if ($result = $this->first()) {
            return $result;
        }
        return null;
    }

    /**
     * @param $value
     */
    public function add($value)
    {
        $this->elements[] = $value;
    }

    /**
     * Clear the internal array
     */
    public function clear()
    {
        $this->elements = [];
    }

    /**
     * Checks if collection contains provided element.
     *
     * @param $element
     *
     * @return bool
     */
    public function contains($element)
    {
        return in_array($element, $this->elements, true);
    }

    public function getIterator()
    {
        return new ArrayIterator($this->elements);
    }

    public function offsetExists($offset)
    {
        return $this->containsKey($offset);
    }

    /**
     * Checks if collection contains provided key.
     *
     * @param $key
     *
     * @return bool
     */
    public function containsKey($key)
    {
        return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
    }

    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    /**
     * @param $key
     * @return mixed|null
     */
    public function get($key)
    {
        if (isset($this->elements[$key])) {
            return $this->elements[$key];
        }

        return null;
    }

    public function offsetSet($offset, $value)
    {
        $this->set($offset, $value);
    }

    /**
     * @param $key
     * @param $element
     */
    public function set($key, $element)
    {
        $this->elements[$key] = $element;
    }

    public function offsetUnset($offset)
    {
        $this->remove($offset);
    }

    public function remove($key)
    {
        if (isset($this->elements[$key]) || array_key_exists($key, $this->elements)) {
            $removed = $this->elements[$key];
            unset($this->elements[$key]);

            return $removed;
        }

        return null;
    }

    public function count()
    {
        return count($this->elements);
    }

    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * @return array
     */
    public function toArray()
    {
        return $this->elements;
    }

    /**
     * {@inheritdoc}
     */
    public function filter(Closure $p)
    {
        return new static(array_filter($this->elements, $p));
    }

    protected function extractProperties($propertyFetchMethod)
    {
        $values = [];
        $this->forAll(
            function ($entry) use (&$values, $propertyFetchMethod) {
                $values[] = $entry->{$propertyFetchMethod}();
            }
        );

        return $values;
    }

    /**
     * @param callable|Closure $p
     */
    public function forAll(Closure $p)
    {
        foreach ($this->elements as $key => $element) {
            $p($element, $key);
        }
    }
}