BuildR\Collection\Set

Complexity

Total Complexity

37

Size/Duplication

Total Lines	238
Duplicated Lines	11.76 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

97.44%

Importance

Changes	5
Bugs	2	Features	2

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	add()	0	7	2
A	addAll()	0	7	2
A	clear()	0	3	1
A	contains()	0	3	2
A	containsAll()	15	15	3
A	containsAny()	0	11	3
A	equals()	0	11	2
A	isEmpty()	0	3	1
A	remove()	0	9	2
A	removeAll()	13	13	3
A	retainAll()	0	15	3
A	size()	0	3	2
A	current()	0	3	1
A	next()	0	3	1
A	key()	0	3	1
A	valid()	0	3	1
A	rewind()	0	3	1
A	count()	0	3	1
A	checkAndConvertInputCollection()	0	7	2
A	toArray()	0	3	1

<?php namespace BuildR\Collection;

use BuildR\Collection\Exception\CollectionException;
use BuildR\Collection\Interfaces\CollectionInterface;

/**
 * Set type (Collection implementation)
 * Sets only store scalar types
 *
 * BuildR PHP Framework
 *
 * @author Zoltán Borsos <zolli07@gmail.com>
 * @package Collection
 *
 * @copyright    Copyright 2015, Zoltán Borsos.
 * @license      https://github.com/Zolli/BuildR/blob/master/LICENSE.md
 * @link         https://github.com/Zolli/BuildR
 */
class Set implements CollectionInterface {

    protected $data = [];

    private $position = 0;

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

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

    /**
     * {@inheritdoc}
     */
    public function add($element) {
        if(!is_scalar($element)) {
            throw CollectionException::nonScalarTypeGiven(gettype($element));
        }

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

    /**
     * {@inheritdoc}
     */
    public function addAll($elements) {
        $elements = $this->checkAndConvertInputCollection($elements);

        foreach($elements as $item) {
            $this->add($item);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clear() {
        $this->data = [];
    }

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

    /**
     * {@inheritdoc}
     */
    public function containsAll($elements) {
        $elements = $this->checkAndConvertInputCollection($elements);

        $result = TRUE;

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

                break;
            }
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function containsAny($elements) {
        $elements = $this->checkAndConvertInputCollection($elements);

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

        return FALSE;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(CollectionInterface $collection) {
        //First check the size, if this not equals the tow collection
        //not be identical
        if($collection->size() !== $this->size()) {
            return FALSE;
        }

        //Use strict comparison to check arrays are equals
        //(Values and orders)
        return $collection->toArray() === $this->data;
    }

    /**
     * {@inheritdoc}
     */
    public function isEmpty() {
        return empty($this->data);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($element) {
        if(($index = array_search($element, $this->data)) !== FALSE) {
            unset($this->data[$index]);

            return TRUE;
        }

        return FALSE;
    }

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

        $result = FALSE;

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

        return $result;
    }

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

        $result = FALSE;

        foreach($this->data as $index => $data) {
            if(array_search($data, $elements) === FALSE) {
                unset($this->data[$index]);

                $result = TRUE;
            }
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function size() {
        return (is_array($this->data)) ? count($this->data) : 0;
    }

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public function current() {
        return $this->data[$this->position];
    }

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public function next() {
        $this->position++;
    }

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public function key() {
        return $this->position;
    }

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public function valid() {
        return isset($this->data[$this->position]);
    }

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public function rewind() {
        $this->position--;
    }

    /**
     * {@inheritdoc}
     */
    public function count() {
        return $this->size();
    }

    /**
     * @param array|\BuildR\Collection\Interfaces\CollectionInterface $elements
     *
     * @return array
     */
    protected function checkAndConvertInputCollection($elements) {
        if($elements instanceof CollectionInterface) {
            $elements = $elements->toArray();
        }

        return $elements;
    }

}