BuildR\Collection\Collection\AbstractCollection

Complexity

Total Complexity

19

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

53.33%

Importance

Changes	5
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	setStrictType()	0	4	1
A	isStrict()	0	3	1
A	toArray()	0	3	1
A	clear()	0	3	1
A	isEmpty()	0	3	1
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	doTypeCheck()	0	13	4
A	collectionToArray()	0	7	2

<?php namespace BuildR\Collection\Collection;

use BuildR\Collection\Exception\CollectionException;

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

    /**
     * @type array
     */
    protected $data = [];

    /**
     * @type NULL|callable
     */
    protected $typeChecker;

    /**
     * @type NULL|string
     */
    protected $typeCheckFailMessage;

    /**
     * {@inheritdoc}
     */
    public function setStrictType(callable $typeCheck, $message = NULL) {
        $this->typeChecker = $typeCheck;
        $this->typeCheckFailMessage = $message;
    }

    /**
     * {@inheritdoc}
     */
    public function isStrict() {
        return is_callable($this->typeChecker);
    }

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public function valid() {
        return key($this->data) !== NULL;
    }

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

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

    /**
     * Executes the type check if the collection is strict. Always
     * returns true, when the collection is not strictly typed
     *
     * @param mixed $value
     *
     * @return bool
     *
     * @throws \BuildR\Collection\Exception\CollectionException
     */
    protected function doTypeCheck($value) {
        if($this->isStrict()) {
            $result = (bool) $this->typeChecker($value);

The method typeChecker() does not seem to exist on object<BuildR\Collection\Collection\AbstractCollection>.

            if($result === FALSE) {
                $message = ($this->typeCheckFailMessage === NULL) ? gettype($value) : $this->typeCheckFailMessage;

                throw CollectionException::typeException($message);
            }

            return TRUE;
        }
    }

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

        return $elements;
    }

}