Late-State Exception

<?PHP
    NAMESPACE ILLI\Core\Std\Def;
    USE ILLI\Core\Std\Def;
    USE ILLI\Core\Std\Def\ADV\ComponentInitializationException;
    USE ILLI\Core\Std\Def\ADV\ComponentMethodCallException;
    USE ILLI\Core\Std\Exception\ArgumentExpectedException;
    USE ILLI\Core\Std\Exception\ClassNotFoundException;
    USE ILLI\Core\Std\Invoke;
    USE ILLI\Core\Std\Spl\Fsb;
    USE ILLI\Core\Util\Spl;

    CLASS ADV
    {
        #:props:
        /**
         * cache ADT
         *
         * :hashAddr<string>
         *  instance of get_called_class(): ILLI\Core\Std\Def\ADT*
         *  instance of __CLASS__:      ILLI\Core\Std\Def\ADT<hash>
         *
         * :ADT<ILLI\Core\Std\Def\ADT>
         *  the ADT for the type-value-pair
         *
         * @var     array [{:hashAddr} => ILLI\Core\Std\Spl\Fsb[long offset => {:ADT}]]
         */
        private static  $__gc       = [];

        /**
         * gc hash address
         *
         * @var     mixed
         * @see     ::$__gc
         */
        protected   $__name     = NULL;

        /**
         * stored value, type defined by ADT
         *
         * @var     mixed
         * @see     ::$__gc
         */
        protected   $__data     = NULL;
        #::

        /**
         * Instantiate a new ADT-Value-Pair.
         *
         * The ADV stores data. The expected data-type is defined by ADT-definition(s).
         *
         * (An generic <long> forbids all except integers. Multi-type-def <string|array> forbids all
         * except strings and arrays.)
         *
         * :offset<long>
         *  zero-based index
         *
         * :gcType<string>
         *  a valid __const_Type
         *
         * @param   string  $__defineType   {:gcType}
         * @param   array   $__defineType   [{:offset} => {:gcType}]
         * @throws  ILLI\Core\Std\Exception\ArgumentExpectedException when given spl-type is not of type string
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentInitializationException
         * @see     ILLI\Core\Std\Def\ADT::__construct()
         */
        public function __construct($__defineType)
        {
            try
            {
                $d = (array) $__defineType;
                $n = $this->__name = $this->createHashAddr($d);
                $t = &self::$__gc[$n];

                if(TRUE === isset($t))
                    return;

                $t = Fsb::fromArray(Def::types($d), TRUE);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentInitializationException';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                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\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_DTOR
         * @void
         */
        public function __destruct()
        {
            try
            {
                if(($c = get_called_class()) === __CLASS__)
                    unset(self::$__gc[$this->getName()]);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                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
         *
         * use ADT to validate the value
         *
         * @param   mixed $__value
         * @return  boolean
         * @catchable   ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
         * @see     ILLI\Core\Std\Def\ADT::validate()
         */
        public function validate($__value)
        {
            try
            {
                return $this->getGC()->evaluate('validate', [$__value]);
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                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 type equals with 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(TRUE === $this->validate($__value))
                {
                    $this->__data = $__value;
                    return $this;
                }

                $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)
                ]);

                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ['method' => __METHOD__], ComponentMethodCallException::ERROR_SET_VALUE_TYPE_EXPECTED)
                    : new $e($E, ['method' => __METHOD__], $e::ERROR_SET_VALUE_TYPE_EXPECTED);

            }
            catch(ComponentMethodCallException $E)
            {
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E->getPrevious(), ['method' => __METHOD__])
                    : new $e($E->getPrevious(), ['method' => __METHOD__]);
            }
            catch(\Exception $E)
            {
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_SET, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_SET, ['method' => __METHOD__]);
            }
        }

        /**
         * get the stored data or NULL when nothing was set
         *
         * @return  mixed|NULL
         * @catchable   ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
         */
        public function get()
        {

            try
            {
                return $this->__data;
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_GET, ['method' => __METHOD__]);
            }
        }

        /**
         * get ADT definition
         *
         * @return  ILLI\Core\Std\Spl\Fsb
         * @catchable   ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
         */
        public function getGC()
        {
            try
            {
                return self::$__gc[$this->getName()];
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_GC, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_GET_GC, ['method' => __METHOD__]);
            }
        }

        /**
         * get gc hash address
         *
         * @return  string
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_GET_NAME
         * @see     ::$__gc
         */
        public function getName()
        {
            try
            {
                return $this->__name;
            }
            catch(\Exception $E)
            {
                $c = get_called_class();
                $e = $c.'\ComponentMethodCallException';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                throw ($c === __CLASS__ || FALSE === class_exists($e))
                    ? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_NAME, ['method' => __METHOD__])
                    : new $e($E, $e::ERROR_GET_NAME, ['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';
                #! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
                #! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
                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__]);
            }
        }
    }