BuildR\Collection\ArrayList\ArrayList

Complexity

Total Complexity

36

Size/Duplication

Total Lines	217
Duplicated Lines	15.21 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	8
Bugs	2	Features	2

18 Methods

Rating	Name	Duplication	Size	Complexity
A	removeAll()	0	8	2
A	subList()	0	5	1
A	__construct()	0	5	2
A	add()	0	3	1
A	addAll()	0	5	2
A	addTo()	0	5	1
A	get()	0	5	2
A	filter()	0	5	1
A	set()	0	12	2
A	contains()	0	3	2
A	containsAt()	0	5	1
A	containsAll()	15	15	3
A	containsAny()	11	11	3
A	indexOf()	0	3	1
B	equals()	0	17	5
A	removeAt()	0	7	2
A	retainAll()	7	11	3
A	checkIndex()	0	7	2

<?php namespace BuildR\Collection\ArrayList;

use BuildR\Collection\Collection\AbstractCollection;
use BuildR\Collection\Exception\ListException;
use BuildR\Collection\Utils\ArrayFilter;

/**
 * ArrayList implementation
 *
 * BuildR PHP Framework
 *
 * @author Zoltán Borsos <zolli07@gmail.com>
 * @package Collection
 * @subpackage ArrayList
 *
 * @copyright    Copyright 2015, Zoltán Borsos.
 * @license      https://github.com/Zolli/BuildR/blob/master/LICENSE.md
 * @link         https://github.com/Zolli/BuildR
 */
class ArrayList extends AbstractCollection implements ListInterface {

    /**
     * ArrayList constructor.
     *
     * @param array|NULL $elements
     */
    public function __construct($elements = NULL) {
        if(is_array($elements)) {
            $this->addAll($elements);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function add($element) {
        $this->data[] = $element;
    }

    /**
     * {@inheritDoc}
     */
    public function addAll($elements) {
        foreach($elements as $element) {
            $this->add($element);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function addTo($index, $element) {
        $index = $this->checkIndex($index);

        array_splice($this->data, $index, 0, $element);
    }

    /**
     * {@inheritDoc}
     */
    public function get($index) {
        $index = $this->checkIndex($index);

        return (isset($this->data[$index])) ? $this->data[$index] : NULL;
    }

    /**
     * {@inheritDoc}
     */
    public function filter(callable $filter) {
        $result = ArrayFilter::execute($this->data, $filter);

        return new static($result);
    }

    /**
     * {@inheritDoc}
     */
    public function set($index, $element) {
        $index = $this->checkIndex($index);
        $returns = NULL;

        if(isset($this->data[$index])) {
            $returns = $this->data[$index];
        }

        $this->data[$index] = $element;

        return $returns;
    }

    /**
     * {@inheritDoc}
     */
    public function contains($element) {
        return (array_search($element, $this->data, TRUE) === FALSE) ? FALSE : TRUE;
    }

    /**
     * {@inheritDoc}
     */
    public function containsAt($index) {
        $index = $this->checkIndex($index);

        return isset($this->data[$index]);
    }

    /**
     * {@inheritDoc}
     */
    public function containsAll($elements) {

This method seems to be duplicated in your project.

        $elements = $this->collectionToArray($elements);

        $result = TRUE;

        foreach($elements as $item) {
            if($this->contains($item) === FALSE) {
                $result = FALSE;

                break;
            }
        }

        return $result;
    }

    /**
     * {@inheritDoc}
     */
    public function containsAny($elements) {

This method seems to be duplicated in your project.

        $elements = $this->collectionToArray($elements);

        foreach($elements as $item) {
            if($this->contains($item) === TRUE) {
                return TRUE;
            }
        }

        return FALSE;
    }

    /**
     * {@inheritDoc}
     */
    public function indexOf($element) {
        return array_search($element, $this->data, TRUE);
    }

    /**
     * {@inheritDoc}
     */
    public function equals(ListInterface $collection) {
        if($collection->size() !== $this->size()) {
            return FALSE;
        }

        $elements = $collection->toArray();

        foreach($elements as $key => $value) {
            if(isset($this->data[$key]) && $this->data[$key] === $value) {
                continue;
            }

            return FALSE;
        }

        return TRUE;
    }

    /**
     * {@inheritDoc}
     */
    public function removeAt($index) {
        $index = $this->checkIndex($index);

        if(isset($this->data[$index])) {
            unset($this->data[$index]);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function removeAll($elements) {
        $elements = $this->collectionToArray($elements);

        foreach($elements as $item) {
            $index = $this->indexOf($item);
            $this->removeAt($index);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function subList($offset, $length) {
        $slice = array_slice($this->data, $offset, $length, FALSE);

        return new static($slice);
    }

    /**
     * {@inheritDoc}
     */
    public function retainAll($elements) {
        $elements = $this->collectionToArray($elements);

        foreach($this->data as $index => $item) {

This code seems to be duplicated across your project.

            if(array_search($item, $elements, TRUE) !== FALSE) {
                continue;
            }

            unset($this->data[$index]);
        }
    }

    /**
     * Validates the given index. Check if this a numeric value
     * and throws an exception if not. If the index is numeric
     * the value is casted to array and returned.
     *
     * @param mixed $index
     *
     * @return int
     *
     * @throws \BuildR\Collection\Exception\ListException
     */
    protected function checkIndex($index) {
        if(!is_numeric($index)) {
            throw ListException::nonNumericIndex(gettype($index));
        }

        return (int) $index;
    }

}