Strict Array

<?PHP
    NAMESPACE ILLI\Core\Std\Def;
    USE ILLI\Core\Std\Exception\ArgumentExpectedException;
    USE ILLI\Core\Std\Def;
    USE ILLI\Core\Std\Def\__const_Type;
    USE ILLI\Core\Std\Def\ADV;
    USE ILLI\Core\Std\Def\ADVArrayKeyValue\ComponentMethodCallException;
    USE ILLI\Core\Std\Def\ADVArrayKeyValue\ComponentInitializationException;
    USE ILLI\Core\Std\Spl\FsbCollection;
    USE ILLI\Core\Util\Spl;

    CLASS ADVArrayKeyValue EXTENDS \ILLI\Core\Std\Def\ADV
    {
        /**
         * cache ADT for key and value
         *
         * :index<long>
         *  0   key
         *  1   value
         *
         * :hashAddr<string>
         *  instance of get_called_class(): ILLI\Core\Std\Def\ADV*
         *  instance of __CLASS__:      ILLI\Core\Std\Def\ADVArrayKeyValue<hash>
         *
         * :ADT<ILLI\Core\Std\Def\ADT>
         *  the ADT for {:index}
         *
         * @var     array [{:hashAddr} => ILLI\Core\Std\Spl\FsbCollection[{:index} => ILLI\Core\Std\Spl\FsbCollection[long offset => {:ADT}]]]
         */
        private static $__kvgc = NULL;

        #:ILLI\Core\Std\Def\ADV:
        /**
         * Instantiate a new ADVArray with ADT for key and value.
         *
         * The base-type for this ADV is an array. The difference to ADVArray is an ADT definition for offset-key and -value.
         *
         * @param   string  $__defineKeyType    {:gcType}
         * @param   array   $__defineKeyType    [{:offset} => {:gcType}]
         * @param   string  $__defineValType    {:gcType}
         * @param   array   $__defineValType    [{:offset} => {:gcType}]
         * @param   array   $__data         initial-array
         * @catchable   ILLI\Core\Std\Def\ADVArrayKeyValue\ComponentInitializationException
         * @see     ILLI\Core\Std\Def\ADV::__construct()
         * @see     ILLI\Core\Std\Def::types()
         */
        public function __construct($__defineKeyType = NULL, $__defineValType = NULL, $__data = NULL)
        {
            try
            {
                parent::__construct([__const_Type::SPL_ARRAY]);

                $t = &self::$__kvgc[$this->getName()];

                if(FALSE === isset($t))
                {
                    $t = FsbCollection::fromArray([
                        FsbCollection::fromArray(NULL === $__defineKeyType ? [] : Def::types((array) $__defineKeyType)),
                        FsbCollection::fromArray(NULL === $__defineValType ? [] : Def::types((array) $__defineValType))]);
                }

                if(NULL !== $__data)
                    $this->set($__data);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentInitializationException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentInitializationException($E, ['class' => get_called_class()])
                    : new $e($E, ['class' => get_called_class()]);
            }
        }

        /**
         * Destroy anonymous ATV definitions
         *
         * @catchable   ILLI\Core\Std\Def\ADVArrayKeyValue\ComponentMethodCallException ComponentMethodCallException::ERROR_DTOR
         * @void
         */
        public function __destruct()
        {
            try
            {
                if(($c = get_called_class()) === __CLASS__)
                    unset(self::$__kvgc[$this->getName()]);

                parent::__destruct();
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_DTOR, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_DTOR, ['method' => __METHOD__]);
            }
        }

        /**
         * value-validation, offset-validation
         *
         * use gc-ADT to validate the value; use kvgc-ADT to validate the offset-name and the offset-value
         *
         * @param   mixed $__value
         * @return  boolean
         * @catchable   ILLI\Core\Std\Exception\ADVArrayKeyValue\ComponentMethodCallException
         * @see     ILLI\Core\Std\Def\ADT::validate()
         * @see     ILLI\Core\Std\Def\ADV::validate()
         */
        public function validate($__value)
        {
            try
            {
                if(FALSE === $this->getGC()->evaluate('validate', [$__value]))
                    return FALSE;

                foreach($__value as $k => $v)
                {
                    if(FALSE === $this->validateKey($k))
                        return FALSE;

                    if(FALSE === $this->validateVal($v))
                        return FALSE;
                }

                return TRUE;
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_VALIDATE, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_VALIDATE, ['method' => __METHOD__]);
            }
        }

        /**
         * store data when value-type equals with gc-ADT, when offset-type equals with kvgc-ADT and when offset-value equals with kvgc-ADT
         *
         * @param   mixed $__value
         * @return  this
         * @throws  ILLI\Core\Std\Exception\ArgumentExpectedException on validation-fail
         * @catchable   ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
         * @see     ::validate()
         */
        public function set($__value)
        {
            $c = get_called_class();
            $e = $c.'\ComponentMethodCallException';

            try
            {
                if(FALSE === parent::validate($__value))
                {
                    $E = new ArgumentExpectedException
                    ([
                        'target'    => get_called_class(),
                        'expected'  => implode('|', array_unique($this->getGC()->invoke('toString'))),
                        'detected'  => $t = getType($v = $__value),
                        'value'     => is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
                    ]);

                    throw ($c === __CLASS__ || FALSE === class_exists($e))
                        ? new ComponentMethodCallException($E, ['method' => __METHOD__], ComponentMethodCallException::ERROR_SET_TYPE_EXPECTED)
                        : new $e($E, ['method' => __METHOD__], $e::ERROR_SET_TYPE_EXPECTED);
                }

                $i = 0;
                foreach($__value as $k => $v)
                {
                    if(FALSE === $this->validateKey($k))
                    {
                        $E = new ArgumentExpectedException([
                            'target'    => $this->getName().'['.$i.']',
                            'expected'  => implode('|', array_unique($this->getKeyGC()->invoke('toString'))),
                            'detected'  => $t = getType($k),
                            'value'     => is_object($k) ? get_class($k) : (is_scalar($k) ? $k : NULL)
                        ]);

                        $a =
                        [
                            'offset'    => $i,
                            'class'     => get_called_class()
                        ];

                        throw ($c === __CLASS__ || FALSE === class_exists($e))
                            ? new ComponentMethodCallException($E, $a, ComponentMethodCallException::SET_OFFSET_KEY_TYPE_EXPECTED)
                            : new $e($E, $a, $e::SET_OFFSET_KEY_TYPE_EXPECTED);
                    }

                    if(FALSE === $this->validateVal($v))
                    {
                        $E = new ArgumentExpectedException([
                            'target'    => $this->getName().'['.$i.']',
                            'expected'  => implode('|', array_unique($this->getValGC()->invoke('toString'))),
                            'detected'  => $t = getType($v),
                            'value'     => is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
                        ]);

                        $a =
                        [
                            'offset'    => $i,
                            'class'     => get_called_class()
                        ];

                        throw ($c === __CLASS__ || FALSE === class_exists($e))
                            ? new ComponentMethodCallException($E, $a, ComponentMethodCallException::SET_OFFSET_VAL_TYPE_EXPECTED)
                            : new $e($E, $a, $e::SET_OFFSET_VAL_TYPE_EXPECTED);
                    }

                    $i++;
                }

                $this->__data = $__value;
                return $this;

            }
            catch(ComponentMethodCallException $E)
            {
                throw $E;
            }
            catch(\Exception $E)
            {
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_SET, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_SET, $e::ERROR_SET,  ['method' => __METHOD__]);
            }
        }

        protected function createHashAddr(array $__defineTypes = [])
        {
            try
            {
                #~ performanced ADT: cache request by called-class; otherwise by hash
                return ($c = get_called_class()) === __CLASS__ ? Spl::nameWithHash($c, $this) : $c;
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_CREATE_HASH_ADDR, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_CREATE_HASH_ADDR, ['method' => __METHOD__]);
            }
        }
        #::

        /**
         * offset key validation
         *
         * use kvgc-ADT to validate the offset-name
         *
         * @param   mixed $__value
         * @return  boolean
         * @catchable   ILLI\Core\Std\Exception\ADVArrayKeyValue\ComponentMethodCallException
         * @see     ILLI\Core\Std\Def\ADT::validate()
         */
        public function validateKey($__value)
        {
            try
            {
                return $this->getKeyGC()->evaluate('validate', [$__value]);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_VALIDATE_OFFSET_KEY, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_VALIDATE_OFFSET_KEY, ['method' => __METHOD__]);
            }
        }

        /**
         * offset value validation
         *
         * use kvgc-ADT to validate the offset-value
         *
         * @param   mixed $__value
         * @return  boolean
         * @catchable   ILLI\Core\Std\Exception\ADVArrayKeyValue\ComponentMethodCallException
         * @see     ILLI\Core\Std\Def\ADT::validate()
         */
        public function validateVal($__value)
        {
            try
            {
                return $this->getValGC()->evaluate('validate', [$__value]);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_VALIDATE_OFFSET_VAL, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_VALIDATE_OFFSET_VAL, ['method' => __METHOD__]);
            }
        }

        /**
         * get ADT definition for offset-key
         *
         * @return  ILLI\Core\Std\Spl\FsbCollection
         * @catchable   ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
         */
        public function getKeyGC()
        {
            try
            {
                return self::$__kvgc[$this->getName()]->offsetGet(0);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_GC_KEY, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_GET_GC_KEY, ['method' => __METHOD__]);
            }
        }

        /**
         * get ADT definition for offset-value
         *
         * @return  ILLI\Core\Std\Spl\FsbCollection
         * @catchable   ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
         */
        public function getValGC()
        {
            try
            {
                return self::$__kvgc[$this->getName()]->offsetGet(1);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_GC_VAL, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_GET_GC_VAL, ['method' => __METHOD__]);
            }
        }
    }