Catchable/Throwable

<?PHP
    NAMESPACE ILLI\Core\Std\Def;
    USE ILLI\Core\Std\Def\__const_Type;
    USE ILLI\Core\Std\Def\ADT\ComponentInitializationException;
    USE ILLI\Core\Std\Def\ADT\ComponentMethodCallException;
    USE ILLI\Core\Std\Exception\ArgumentExpectedException;
    USE ILLI\Core\Std\Exception\ArgumentLengthZeroException;
    USE ILLI\Core\Std\Exception\ArgumentInUseException;
    USE ILLI\Core\Std\Exception\NotSupportedException;
    USE ILLI\Core\Std\Spl\Fsb;
    USE ILLI\Core\Util\Spl;

    CLASS ADT EXTENDS \ILLI\Core\Std\Spl\Fsb
    {
        /**
         * cache typedef request
         *
         * :hashAddr<string>
         *  instance of get_called_class(): ILLI\Core\Std\Def\ADT*
         *  instance of __CLASS__:      ILLI\Core\Std\Def\ADT<hash>
         *
         * :adtDef<ILLI\Core\Std\Spl\Fsb>
         *  collection of defined __const_Type(s)
         *
         * @var     array [{:hashAddr} => {:adtDef}]
         */
        private static $__gc = [];

        /**
         * Instantiate a new Abstract Data Type.
         *
         * define ADT
         *
         * :offset<long>
         *  zero-based index
         *
         * :gcType<string>
         *  a valid __const_Type
         *
         * @param   array $__defineTypes [{:offset} => {:gcType}]
         * @throws  ILLI\Core\Std\Exception\ArgumentLengthZeroException when definition is an empty array
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentInitializationException
         * @see     ILLI\Core\Std\Def\__const_Type
         * @see     ILLI\Core\Std\Def\ADTInstance
         * @see     ILLI\Core\Std\Spl\Fsb
         */
        public function __construct(array $__defineTypes = [])
        {
            try
            {
                if([] === $__defineTypes)
                    throw new ComponentMethodCallException
                    (
                        ComponentMethodCallException::CTOR_DEFINITION_LENGTH_ZERO,
                        ['method' => __METHOD__],
                        new ArgumentLengthZeroException
                    );

                $n = $this->createHashAddr($__defineTypes);
                $t = &self::$__gc[$n];

                parent::setSize(1);
                parent::offsetSet(0, $n);

                if(FALSE === isset($t))
                    $t = Fsb::fromArray($this->parseDef($__defineTypes));
            }
            catch(\Exception $E)
            {
                throw new ComponentInitializationException($E, ['class' => get_called_class()]);
            }
        }

        /**
         * value validation
         *
         * The type of given value equals with one of the registered gc-types
         *
         * @param   mixed $__value
         * @return  boolean
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_VALIDATE
         * @see     ILLI\Core\Std\Def\__const_Type
         */
        public function validate($__value)
        {
            try
            {
                $v = &$__value;
                $t = getType($v);

                foreach($this->getGC() as $h)
                {
                    if($t === $h
                    ||($t === __const_Type::SPL_OBJECT && (class_exists($h) || interface_exists($h)) && (is_subclass_of($v, $h) || $v instanceOf $h)))
                        return TRUE;
                }

                return FALSE;
            }
            catch(\Exception $E)
            {
                throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_VALIDATE, ['method' => __METHOD__]);
            }
        }

        /**
         * get ADT-gc hash address
         *
         * @return  string
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_GET_NAME
         * @see     ::$__gc
         */
        public function getName()
        {
            try
            {
                return parent::offsetGet(0);
            }
            catch(\Exception $E)
            {
                throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_NAME, ['method' => __METHOD__]);
            }
        }

        /**
         * get ADT-gc
         *
         * @return  ILLI\Core\Std\Spl\Fsb
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_GET_GC
         * @see     ::$__gc
         */
        public function getGC()
        {
            try
            {
                return self::$__gc[$this->getName()];
            }
            catch(\Exception $E)
            {
                throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_GC, ['method' => __METHOD__]);
            }
        }

        /**
         * join registered gc-type(s)
         *
         * @return  ILLI\Core\Std\Spl\Fsb
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_TO_STRING
         * @see     ::$__gc
         * @see     ILLI\Core\Std\Def\__const_Type
         */
        public function toString()
        {
            try
            {
                return implode('|', $this->getGC()->toArray());
            }
            catch(\Exception $E)
            {
                throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_TO_STRING, ['method' => __METHOD__]);
            }
        }

        /**
         * generate gc-hash-address from called-class or from spl_object_hash
         *
         * :offset<long>
         *  zero-based index
         *
         * :gcType<string>
         *  a valid __const_Type
         *
         * @param   array $__defineTypes [{:offset} => {:gcType}]
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_CREATE_HASH_ADDR
         * @return  string
         * @see     ::$__gc
         */
        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)
            {
                throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_CREATE_HASH_ADDR, ['method' => __METHOD__]);
            }
        }

        /**
         * validate typedef request
         *
         * :offset<long>
         *  zero-based index
         *
         * :gcType<string>
         *  a valid __const_Type
         *
         * @param   array $__defineTypes [{:offset} => {:gcType}]
         * @throws  ILLI\Core\Std\Exception\ArgumentExpectedException when {:gcType} is not of type string
         * @throws  ILLI\Core\Std\Exception\ArgumentLengthZeroException result-array is empty
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_PARSE_DEF_EXPECTED_STRING
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_PARSE_DEF_RESULT_LENGTH_ZERO
         * @catchable   ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_PARSE_DEF
         */
        protected function parseDef(array $__defineTypes)
        {
            try
            {
                $r = [];

                foreach($__defineTypes as $k => $v)
                {
                    if(FALSE === is_string($v))
                        throw new ComponentMethodCallException
                        (
                            ComponentMethodCallException::ERROR_PARSE_DEF_EXPECTED_STRING,
                            ['offset' => $k, 'class' => get_called_class()],
                            new ArgumentExpectedException
                            ([
                                'target'    => $this->getName().'['.$k.']',
                                'expected'  => 'string',
                                'detected'  => $t = getType($v),
                                'value'     => is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
                            ])
                        );

                    $r[$k] = $v;
                }

                if([] === $r)
                    throw new ComponentMethodCallException
                    (
                        ComponentMethodCallException::ERROR_PARSE_DEF_RESULT_LENGTH_ZERO,
                        ['method' => __METHOD__],
                        new ArgumentLengthZeroException
                    );

                return $r;
            }
            catch(ComponentMethodCallException $E)
            {
                throw $E;
            }
            catch(\Exception $E)
            {
                throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_PARSE_DEF, ['method' => __METHOD__]);
            }
        }