Ballybran\Core\Collections\Collection\IteratorCollection

Complexity

Total Complexity

49

Size/Duplication

Total Lines	262
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	setElementsFromTrustedSource()	0	3	1
A	__construct()	0	6	1
A	toArray()	0	3	1
A	count()	0	3	1
A	current()	0	3	1
A	getIterator()	0	4	1
A	next()	0	3	1
A	getValues()	0	4	1
A	removeElement()	0	8	2
A	offsetSet()	0	6	2
A	first()	0	3	1
A	ksort()	0	4	1
A	add()	0	5	1
A	set()	0	5	1
A	valid()	0	3	1
B	slice()	0	26	8
A	reverse()	0	8	2
A	get()	0	3	2
A	natSort()	0	3	1
A	natcasesort()	0	3	1
A	getKeys()	0	3	1
A	remove()	0	9	3
A	exists()	0	8	3
A	contains()	0	3	1
A	last()	0	3	1
A	indexOf()	0	3	1
A	containsKey()	0	3	2
A	key()	0	3	1
A	find()	0	3	1
A	isEmpty()	0	3	1
A	offsetExists()	0	3	1
A	offsetUnset()	0	3	1
A	offsetGet()	0	3	1

<?php

/**
 * KNUT7 K7F (https://marciozebedeu.com/)
 * KNUT7 K7F (tm) : Rapid Development Framework (https://marciozebedeu.com/)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @link      https://github.com/knut7/framework/ for the canonical source repository
 * @copyright (c) 2015.  KNUT7  Software Technologies AO Inc. (https://marciozebedeu.com/)
 * @license   https://marciozebedeu.com/license/new-bsd New BSD License
 * @author    Marcio Zebedeu - artphoweb@artphoweb.com
 * @version   1.0.2
 */

namespace Ballybran\Core\Collections\Collection;


use Ballybran\Core\Variables\Variable;
use Closure;

/**
 * Class IteratorCollection
 * @package Ballybran\Core\Collections\Collection
 */
class IteratorCollection extends Variable implements \ArrayAccess
{

    /**
     * @var array
     */
    private $elements;
    /**
     * @var int
     */

    //put your code here

    /**
     * IteratorCollection constructor.
     * @param array $elements
     */
    public function __construct(array $elements = array())
    {

        parent::__construct($elements);

        $this->elements = $elements;
    }

    protected function setElementsFromTrustedSource(array $elements)
    {
        $this->elements = $elements;
    }


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

    /**
     * @return \ArrayObject
     */
    public function getIterator()
    {

        return new \ArrayObject($this->elements);
    }

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

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

    /**
     * @param $element
     * Checks if a value exists in an array
     * @see in_array
     * @return bool
     */
    public function contains($element)
    {
        return in_array($element, $this->elements, true);
    }

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

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

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

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

    public function valid()
    {
        return $this->offsetExists($this->elements);

    }

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

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

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

    public function containsKey($key)
    {
        return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
    }

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

    public function remove($key)
    {
        if (!isset($this->elements[$key]) && !array_key_exists($key, $this->elements)) {
            return false;
        } else {
            $removed = $this->elements[$key];
            unset($this->elements[$key]);

            return $removed;
        }
    }

    public function removeElement($element)
    {
        $key = array_search($element, $this->elements, true);
        if (false === $key) {
            return false;
        }
        unset($this->elements[$key]);
        return true;
    }

    public function add($value)
    {
        $this->elements[] = $value;

        return $this;
    }

    public function set($key, $value)
    {
        $this->elements[$key] = $value;

        return true;
    }

    public function ksort()
    {

        return ksort($this->elements);
    }

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

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

    public function exists(Closure $p)
    {
        foreach ($this->elements as $key => $element) {
            if ($p($key, $element)) {
                return true;
            }
        }
        return false;
    }

    /**
     * @return int|string
     * return the position of the  element
     */
    public function indexOf($element)
    {
        return array_search($element, $this->elements);

The expression return array_search($element, $this->elements) could also return false which is incompatible with the documented return type integer|string. Did you maybe forget to handle an error condition?

    }

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

    public function getValues()
    {

        return array_values($this->elements);
    }

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

    public function get($key)
    {
        return isset($this->elements[$key]) ? $this->elements[$key] : null;
    }


    public function slice($start, $end)
    {
        if ($start < 0 || !is_int($start)) {
            throw new \InvalidArgumentException("Start must be a no-negative integer");
        }

        if ($end < 0 || !is_int($end)) {
            throw new \InvalidArgumentException("End must be a positive integer");
        }

        if ($start > $end) {
            throw new \InvalidArgumentException("End must be geater than start");
        }

        if ($end > $this->count() + 1) {
            throw new \InvalidArgumentException("End must be less than the count of the items in the Collection");
        }

        $length = $end - $start + 1;

        $subsetItems = array_slice($this->elements, $start, $length);

            if (null === $subsetItems) {
                return null;
            }
        return $this->setElementsFromTrustedSource($subsetItems);

Are you sure the usage of $this->setElementsFromTrustedSource($subsetItems) targeting Ballybran\Core\Collections\Collection\IteratorCollection::setElementsFromTrustedSource() seems to always return null.

    }

    public function reverse()
    {
        $item = array_reverse($this->elements);
            if (null === $item) {
                    return null;
            }

        return $this->setElementsFromTrustedSource($item);

Are you sure the usage of $this->setElementsFromTrustedSource($item) targeting Ballybran\Core\Collections\Collection\IteratorCollection::setElementsFromTrustedSource() seems to always return null.

    }

    public function find($value)
    {
        $this->get($value);
    }


}