BuildR\Collection\ArrayList\ArrayList

Complexity

Total Complexity

38

Size/Duplication

Total Lines	215
Duplicated Lines	15.35 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	2	Features	1

18 Methods

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

<?php namespace BuildR\Collection\ArrayList;

use BuildR\Collection\Collection\AbstractCollection;

/**
 * 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) {
        array_splice($this->data, $index, 0, $element);
    }

    /**
     * {@inheritDoc}
     */
    public function get($index) {
        return (isset($this->data[$index])) ? $this->data[$index] : NULL;
    }

    /**
     * {@inheritDoc}
     */
    public function filter(callable $filter) {
        //@codeCoverageIgnoreStart
        if(defined('HHVM_VERSION')) {
            return $this->executeHhvmArrayFilter($filter);
        }
        //@codeCoverageIgnoreEnd

        $result = array_filter($this->data, $filter, ARRAY_FILTER_USE_BOTH);

        return new static($result);
    }

    /**
     * {@inheritDoc}
     */
    public function set($index, $element) {
        $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) {
        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) {
        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]);
        }
    }

    /**
     * The HHVM is not compatible with the $flag attribute that introduced in PHP 5.6
     * This is a fallback method that provides same functionality on HHVM that
     * ARRAY_FILTER_BOTH argument on PHP 5.6
     *
     * @param callable $filter
     *
     * @return static
     */
    protected function executeHhvmArrayFilter(callable $filter) {
        $returnedList = new static();

        foreach($this->data as $index => $value) {
            if(call_user_func_array($filter, [$value, $index]) === TRUE) {
                $returnedList->add($value);
            }
        }

        return $returnedList;
    }

}