Condorcet\DataManager\ArrayManager

Complexity

Total Complexity

72

Size/Duplication

Total Lines	359
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

91.28%

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	1	1
A	__destruct()	0	4	1
A	__clone()	0	4	1
A	__sleep()	0	8	1
A	__wakeup()	0	5	1
A	offsetExists()	0	4	4
B	offsetSet()	0	26	5
A	offsetUnset()	0	18	4
B	offsetGet()	0	20	5
A	rewind()	0	7	1
A	current()	0	3	1
A	key()	0	8	3
A	next()	0	17	4
A	setCursorOnNextKeyInArray()	0	9	2
A	valid()	0	3	2
A	count()	0	3	1
A	getFullDataSet()	0	11	2
A	keyExist()	0	8	4
A	getFirstKey()	0	10	2
A	getContainerSize()	0	4	1
A	getCacheSize()	0	4	1
A	debugGetCache()	0	4	1
	preDeletedTask()	0	1	?
A	regularize()	0	10	3
A	checkRegularize()	0	9	3
A	populateCache()	0	15	4
A	clearCache()	0	10	2
A	isUsingHandler()	0	4	1
A	resetCounter()	0	4	2
A	resetMaxKey()	0	14	4
A	importHandler()	0	23	3
A	closeHandler()	0	14	2
	getDataContextObject()	0	1	?

<?php
/*
    Condorcet PHP Class, with Schulze Methods and others !

    By Julien Boudry - MIT LICENSE (Please read LICENSE.txt)
    https://github.com/julien-boudry/Condorcet
*/
declare(strict_types=1);


namespace Condorcet\DataManager;

use Condorcet\DataManager\DataContextInterface;
use Condorcet\DataManager\DataHandlerDrivers\DataHandlerDriverInterface;
use Condorcet\CondorcetException;
use Condorcet\CondorcetVersion;

abstract class ArrayManager implements \ArrayAccess, \Countable, \Iterator
{
    use CondorcetVersion;

        //////

    public static $CacheSize = 2000;
    public static $MaxContainerLength = 2000;

    protected $_Container = [];
    protected $_DataHandler = null;
    protected $_link = [];

    protected $_Cache = [];
    protected $_CacheMaxKey = 0;
    protected $_CacheMinKey = 0;

    protected $_cursor = null;
    protected $_counter = 0;
    protected $_maxKey = -1;

    public function __construct () {}

    public function __destruct ()
    {
        $this->regularize();
    }

    public function __clone ()
    {
        $this->_link = [];
    }

    public function __sleep () : array
    {
        $this->regularize();
        $this->clearCache();
        $this->rewind();

        return ['_Container','_DataHandler','_link'];
    }

    public function __wakeup ()
    {
        $this->resetMaxKey();
        $this->resetCounter();
    }


/////////// Implement ArrayAccess ///////////

    public function offsetSet($offset, $value) : void
    {
        if ($offset === null) :
            $this->_Container[++$this->_maxKey] = $value;
            ++$this->_counter;
        else :
            $state = $this->keyExist($offset);
            $this->_Container[$offset] = $value;

            if (!$state) :
                ++$this->_counter;

                if ($offset > $this->_maxKey) :
                    $this->_maxKey = $offset;
                endif;

                ksort($this->_Container,SORT_NUMERIC);
            elseif ($this->_DataHandler !== null) :
                $this->_DataHandler->deleteOneEntity($offset, true);
            endif;

            $this->clearCache();
        endif;

        $this->checkRegularize();
    }

    // Use by isset() function, must return false if offset value is null.
    public function offsetExists($offset) : bool
    {
        return ( isset($this->_Container[$offset]) || ($this->_DataHandler !== null && $this->_DataHandler->selectOneEntity($offset) !== false) ) ? true : false ;
    }

    public function offsetUnset($offset) : void
    {
        if ($this->keyExist($offset)) :
            if (array_key_exists($offset, $this->_Container)) :
                $this->preDeletedTask($this->_Container[$offset]);
                unset($this->_Container[$offset]);
            else :
                if (array_key_exists($offset, $this->_Cache)) :
                    $this->preDeletedTask($this->_Cache[$offset]);
                    unset($this->_Cache[$offset]);
                endif;

                $this->_DataHandler->deleteOneEntity($offset, false);
            endif;

            --$this->_counter;
        endif;
    }

    public function offsetGet($offset)
    {
        if (isset($this->_Container[$offset])) :
            return $this->_Container[$offset];
        elseif ($this->_DataHandler !== null) :
            if (array_key_exists($offset, $this->_Cache)) :
                return $this->_Cache[$offset];
            else :
                $oneEntity = $this->_DataHandler->selectOneEntity($offset);
                if ($oneEntity === false) :
                    return null;
                else : 
                    $this->_Cache[$offset] = $oneEntity;
                    return $oneEntity;
                endif;
            endif;
        else :
            return null;
        endif;
    }


/////////// Implement Iterator ///////////

    protected $valid = true;

    public function rewind() : void {
        $this->_cursor = null;
        $this->valid = true;

        reset($this->_Cache);
        reset($this->_Container);
    }

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

    public function key() : ?int
    {
        if ($this->_counter === 0) :
            return null;
        else :
            return ($this->_cursor === null) ? $this->getFirstKey() : $this->_cursor;
        endif;
    }

    public function next() : void
    {
        $oldCursor = $this->_cursor;

        if ($this->_cursor >= $this->_maxKey) :
            // Do nothing
        elseif (!$this->isUsingHandler()) :
            $this->setCursorOnNextKeyInArray($this->_Container);
        else :
            $this->populateCache();
            $this->setCursorOnNextKeyInArray($this->_Cache);
        endif;

        if ($this->_cursor === $oldCursor) :
            $this->valid = false;
        endif;
    }

        protected function setCursorOnNextKeyInArray (array &$array)
        {
            next($array);
            $arrayKey = key($array);

            if ($arrayKey > $this->key()) :
                return $this->_cursor = $arrayKey;
            endif;
        }

    public function valid() : bool {
        return ($this->_counter !== 0) ? $this->valid : false;
    }


/////////// Implement Countable ///////////

    public function count () : int {
        return $this->_counter;
    }

/////////// Array Methods ///////////

    public function getFullDataSet () : array
    {
        if ($this->isUsingHandler()) :
            $this->regularize();
            $this->clearCache();

            return $this->_Cache = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);
        else :
            return $this->_Container;
        endif;
    }

    public function keyExist ($offset) : bool
    {
        if ( array_key_exists($offset, $this->_Container) || ($this->_DataHandler !== null && $this->_DataHandler->selectOneEntity($offset) !== false) ) :
            return true;
        else  :
            return false;
        endif;
    }

    public function getFirstKey () : int
    {
        $r = array_keys($this->_Container);

        if ($this->_DataHandler !== null) :
            $r[] = $this->_DataHandler->selectMinKey();
        endif;

        return (int) min($r);
    }

    public function getContainerSize () : int
    {
        return count($this->_Container);
    }

    public function getCacheSize () : int
    {
        return count($this->_Cache);
    }

    public function debugGetCache () : array
    {
        return $this->_Cache;
    }


/////////// HANDLER API ///////////

    abstract protected function preDeletedTask ($object) : void;

    public function regularize () : bool
    {
        if (!$this->isUsingHandler() || empty($this->_Container)) :
            return false;
        else :
            $this->_DataHandler->insertEntitys($this->_Container);
            $this->_Container = [];
            return true;
        endif;
    }

    public function checkRegularize () : bool
    {
        if ( $this->_DataHandler !== null && self::$MaxContainerLength <= $this->getContainerSize() ) :
            $this->regularize();
            return true;
        else :
            return false;
        endif;
    }

    protected function populateCache () : void
    {
        $this->regularize();

        $currentKey = $this->key();

        if ( empty($this->_Cache) || $currentKey >= $this->_CacheMaxKey || $currentKey < $this->_CacheMinKey ) :
            $this->clearCache();
            $this->_Cache = $this->_DataHandler->selectRangeEntitys($currentKey, self::$CacheSize);

            $keys = array_keys($this->_Cache);
            $this->_CacheMaxKey = max($keys);
            $this->_CacheMinKey = min($keys);
        endif;
    }

    public function clearCache () : void
    {
        foreach ($this->_Cache as $e) :
            $this->preDeletedTask($e);
        endforeach;

        $this->_Cache = [];
        $this->_CacheMaxKey = 0;
        $this->_CacheMinKey = 0;
    }

    public function isUsingHandler ()
    {
        return $this->_DataHandler !== null;
    }

/////////// HANDLER INTERRACTION ///////////

    public function resetCounter () : int
    {
        return $this->_counter = $this->getContainerSize() + ( ($this->isUsingHandler()) ? $this->_DataHandler->countEntitys() : 0 );
    }

    public function resetMaxKey () : ?int
    {
        $this->resetCounter();

        if ($this->count() < 1) :
            $this->_maxKey = -1;
            return null;
        else :
            $maxContainerKey = (empty($this->_Container)) ? null : max(array_keys($this->_Container));
            $maxHandlerKey = ($this->_DataHandler !== null) ? $this->_DataHandler->selectMaxKey() : null;

            return $this->_maxKey = max( $maxContainerKey,$maxHandlerKey );
        endif;
    }

    public function importHandler (DataHandlerDriverInterface $handler) : bool
    {
        if ($handler->countEntitys() === 0) :
            $this->_DataHandler = $handler;
            $this->_DataHandler->_dataContextObject = $this->getDataContextObject();

            try {
                $this->regularize();
            } catch (\Exception $e) {
                $this->_DataHandler = null;
                $this->resetCounter();
                $this->resetMaxKey();
                throw $e;
            }

            $this->resetCounter();
            $this->resetMaxKey();

            return true;
        else :
            throw new CondorcetException;
        endif;
    }

    public function closeHandler () : void
    {
        if ($this->_DataHandler !== null) :
            $this->regularize();
            $this->clearCache();

            $this->_Container = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);

            $this->_DataHandler = null;

            $this->resetCounter();
            $this->resetMaxKey();
        endif;
    }

    abstract public function getDataContextObject () : DataContextInterface;
}