Core\Collection\IdentityWrapper

Complexity

Total Complexity

51

Size/Duplication

Total Lines	370
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	map()	0	8	1
A	forAll()	0	10	3
A	getKeys()	0	5	1
A	getKey()	0	3	1
A	isEmpty()	0	3	1
A	current()	0	3	1
A	toArray()	0	9	2
A	offsetGet()	0	3	1
A	setIdentityExtractor()	0	5	1
A	containsKey()	0	3	1
A	removeElement()	0	3	1
A	first()	0	3	1
A	clear()	0	3	1
A	partition()	0	12	2
A	offsetSet()	0	7	2
A	key()	0	6	2
A	set()	0	6	2
A	contains()	0	3	1
A	get()	0	5	2
A	last()	0	3	1
A	getValues()	0	3	1
A	remove()	0	6	3
A	next()	0	3	1
A	getIterator()	0	3	1
A	getElement()	0	5	1
A	offsetExists()	0	3	1
A	add()	0	3	1
A	filter()	0	3	1
A	indexOf()	0	3	2
A	__construct()	0	3	1
A	count()	0	3	1
A	exists()	0	10	3
A	offsetUnset()	0	3	1
A	slice()	0	9	2
A	getIdentityExtractor()	0	14	3

<?php
/**
 * YAWIK
 *
 * @filesource
 * @copyright (c) 2013 - 2016 Cross Solution (http://cross-solution.de)
 * @license   MIT
 */

namespace Core\Collection;

use Doctrine\Common\Collections\Collection;
use Closure;

class IdentityWrapper implements Collection
{
    
    /**
     * @var Collection
     */
    protected $collection;
    
    /**
     * @var callable
     */
    protected $identityExtractor;
    
    /**
     * @param Collection $collection
     */
    public function __construct(Collection $collection)
    {
        $this->collection = $collection;
    }
    
    /**
     * {@inheritDoc}
     */
    public function count()
    {
        return $this->collection->count();
    }
    
    /**
     * {@inheritDoc}
     */
    public function add($element)
    {
        return $this->collection->add($element);
    }
    
    /**
     * {@inheritDoc}
     */
    public function clear()
    {
        $this->collection->clear();
    }
    
    /**
     * {@inheritDoc}
     */
    public function contains($element)
    {
        return $this->collection->contains($element);
    }
    
    /**
     * {@inheritDoc}
     */
    public function isEmpty()
    {
        return $this->collection->isEmpty();
    }
    
    /**
     * {@inheritDoc}
     */
    public function remove($key)
    {
        $element = $this->getElement($key);
        
        if ($element !== false && $this->collection->removeElement($element)) {
            return $element;
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public function removeElement($element)
    {
        return $this->collection->removeElement($element);
    }
    
    /**
     * {@inheritDoc}
     */
    public function containsKey($key)
    {
        return $this->getElement($key) !== false;
    }
    
    /**
     * {@inheritDoc}
     */
    public function get($key)
    {
        $element = $this->getElement($key);
        
        return $element !== false ? $element : null;
    }
    
    /**
     * {@inheritDoc}
     */
    public function getKeys()
    {
        return $this->collection->map(function ($element) {
            return $this->getKey($element);
        })->toArray();
    }
    
    /**
     * {@inheritDoc}
     */
    public function getValues()
    {
        return $this->collection->getValues();
    }
    
    /**
     * {@inheritDoc}
     */
    public function set($key, $value)
    {
        if ($this->getElement($key) !== false) {
            $this->collection->set($this->collection->indexOf($value), $value);
        } else {
            $this->collection->add($value);
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public function toArray()
    {
        $array = [];
        
        foreach ($this->collection as $element) {
            $array[$this->getKey($element)] = $element;
        }
        
        return $array;
    }
    
    /**
     * {@inheritDoc}
     */
    public function first()
    {
        return $this->collection->first();
    }
    
    /**
     * {@inheritDoc}
     */
    public function last()
    {
        return $this->collection->last();
    }
    
    /**
     * {@inheritDoc}
     */
    public function key()
    {
        $element = $this->collection->current();
        
        if ($element !== false) {
            return $this->getKey($element);
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public function current()
    {
        return $this->collection->current();
    }
    
    /**
     * {@inheritDoc}
     */
    public function next()
    {
        return $this->collection->next();
    }
    
    /**
     * {@inheritDoc}
     */
    public function exists(Closure $p)
    {
        foreach ($this->collection as $element) {
            $key = $this->getKey($element);
            if ($p($key, $element)) {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * {@inheritDoc}
     */
    public function filter(Closure $p)
    {
        return new static($this->collection->filter($p));
    }
    
    /**
     * {@inheritDoc}
     */
    public function forAll(Closure $p)
    {
        foreach ($this->collection as $element) {
            $key = $this->getKey($element);
            if (!$p($key, $element)) {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * {@inheritDoc}
     */
    public function map(Closure $func)
    {
        $mapped = $this->collection->map($func);
        
        // validate mapped elements
        array_map($this->getIdentityExtractor(), $mapped->toArray());
        
        return new static($mapped);
    }
    
    /**
     * {@inheritDoc}
     */
    public function partition(Closure $p)
    {
        $array = $this->toArray();
        $this->collection->clear();
        
        foreach ($array as $key => $element) {
            $this->collection->set($key, $element);
        }
        
        $partitions = $this->collection->partition($p);
        
        return [new static($partitions[0]), new static($partitions[1])];
    }
    
    /**
     * {@inheritDoc}
     */
    public function indexOf($element)
    {
        return $this->collection->indexOf($element) === false ? false : $this->getKey($element);
    }
    
    /**
     * {@inheritDoc}
     */
    public function slice($offset, $length = null)
    {
        $array = [];
        
        foreach ($this->collection->slice($offset, $length) as $element) {
            $array[$this->getKey($element)] = $element;
        }
        
        return $array;
    }
    
    /**
     * {@inheritDoc}
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->toArray());
    }
    
    /**
     * {@inheritDoc}
     */
    public function offsetExists($offset)
    {
        return (bool)$this->getElement($offset);
    }
    
    /**
     * {@inheritDoc}
     */
    public function offsetGet($offset)
    {
        return $this->get($offset);
    }
    
    /**
     * {@inheritDoc}
     */
    public function offsetSet($offset, $value)
    {
        if (!isset($offset)) {
            return $this->add($value);

The expression return $this->add($value) returns the type true which is incompatible with the return type mandated by ArrayAccess::offsetSet() of void.

        }
        
        $this->set($offset, $value);
    }
    
    /**
     * {@inheritDoc}
     */
    public function offsetUnset($offset)
    {
        return $this->remove($offset);
    }
    
    /**
     * @param callable $identityExtractor
     * @return IdentityWrapper
     */
    public function setIdentityExtractor(callable $identityExtractor)
    {
        $this->identityExtractor = $identityExtractor;
        
        return $this;
    }

    /**
     *
     * @return \Core\Collection\callable

The type Core\Collection\callable was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected function getIdentityExtractor()
    {
        if (!isset($this->identityExtractor)) {
            // default identity extractor
            $this->identityExtractor = function ($element) {
                if (!is_callable([$element, 'getId'])) {
                    throw new \LogicException('$element must have getId() method');
                }
                
                return $element->getId();
            };
        }
        
        return $this->identityExtractor;

The expression return $this->identityExtractor returns the type callable which is incompatible with the documented return type Core\Collection\callable.

    }

    /**
     * @param mixed $element
     * @return mixed
     */
    protected function getKey($element)
    {
        return call_user_func($this->getIdentityExtractor(), $element);
    }

    /**
     * @param mixed $element
     * @return mixed
     */
    protected function getElement($key)
    {
        return $this->collection->filter(function ($element) use ($key) {
            return $this->getKey($element) == $key;
        })->first();
    }
}