<?PHP
	NAMESPACE ILLI\Core\Std\Def;
	USE ILLI\Core\Std\Def\__const_ADTClass;
	USE ILLI\Core\Std\Def\__const_Type;
	USE ILLI\Core\Std\Def\ADTInstance;
	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\Invoke;
	USE ILLI\Core\Std\Spl\Fsb;
	USE ILLI\Core\Util\Spl;
	
	CLASS ADT EXTENDS \ILLI\Core\Std\Spl\Fsb
	{
		/**
		 * Instantiate a new Abstract Data Type Definition.
		 *
		 * ADT is the definition as is and doesn't store data.
		 *
		 * A definition can be a base-type or a collection of base-types:
		 * 	<long> forbids all except integers.
		 * 	<string|array> forbids all except strings and arrays.
		 *
		 * define ADT:
		 *
		 * :offset<long>
		 *	zero-based index
		 *
		 * :gcType<string>
		 *	a valid __const_Type
		 *
		 * @param	array $__defineTypes [{:offset} => {:gcType}]
		 * @catchable	ILLI\Core\Std\Def\ADT\ComponentInitializationException
		 * @fires	ILLI\Core\Std\Exception\ArgumentLengthZeroException when definition is an empty array
		 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_CTOR_E_DEFINITION_LENGTH_ZERO
		 * @see		::validate()
		 * @see		::__destruct()
		 * @see		ILLI\Core\Std\Def\__const_Type
		 * @see		ILLI\Core\Std\Def\ADTInstance
		 */
		public function __construct(array $__defineTypes = [])
		{
			$c = get_called_class();
			$e = $c.'\ComponentMethodCallException';
			
			try
			{
				if([] === $__defineTypes)
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException(new ArgumentLengthZeroException, ['method' => __METHOD__], ComponentMethodCallException::ERROR_M_CTOR_E_DEFINITION_LENGTH_ZERO)
						: new $e(new ArgumentLengthZeroException, ['method' => __METHOD__], $e::ERROR_M_CTOR_E_DEFINITION_LENGTH_ZERO);
				
				$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)
			{
				$e = $c.'\ComponentInitializationException';
				throw ($c === __CLASS__ || FALSE === class_exists($e))
					? new ComponentInitializationException($E, ['class' => get_called_class()])
					: new $e($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
		 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_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)
			{
				$c = get_called_class();
				$e = $c.'\ComponentMethodCallException';
				throw ($c === __CLASS__ || FALSE === class_exists($e))
					? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_VALIDATE, ['method' => __METHOD__])
					: new $e($E, $e::ERROR_M_VALIDATE, ['method' => __METHOD__]);
			}
		}
		
		#:define:
			/**
			 * ADT class-mapping
			 *
			 * :gcType<string>
			 *	a valid __const_Type
			 *
			 * :adtClass<string>
			 *	a valid __const_ADTClass
			 *
			 * @var		array [{:gcType} => {:adtClass}]
			 * @see		::define()
			 * @see		ILLI\Core\Std\Def\__const_ADTClass
			 * @see		ILLI\Core\Std\Def\__const_Type
			 * @note	ILLI\Core\Std\Def\__const_ADTClass::SPL_INSTANCE will be created by undefined type-requests in ::define()
			 */
			private static $__def = 
			[
				__const_Type::SPL_ARRAY			=> __const_ADTClass::SPL_ARRAY,
				__const_Type::SPL_BOOLEAN		=> __const_ADTClass::SPL_BOOLEAN,
				__const_Type::SPL_CALLABLE		=> __const_ADTClass::SPL_CALLABLE,
				__const_Type::SPL_CLASS			=> __const_ADTClass::SPL_CLASS,
				__const_Type::SPL_CLOSURE		=> __const_ADTClass::SPL_CLOSURE,
				__const_Type::SPL_DIRECTORY		=> __const_ADTClass::SPL_DIRECTORY,
				__const_Type::SPL_DOUBLE		=> __const_ADTClass::SPL_DOUBLE,
				__const_Type::SPL_FILE			=> __const_ADTClass::SPL_FILE,
				__const_Type::SPL_FLOAT			=> __const_ADTClass::SPL_DOUBLE,
				__const_Type::SPL_FUNCTION		=> __const_ADTClass::SPL_FUNCTION,
				__const_Type::SPL_INTERFACE		=> __const_ADTClass::SPL_INTERFACE,
				__const_Type::SPL_INTEGER		=> __const_ADTClass::SPL_LONG,
				__const_Type::SPL_LONG			=> __const_ADTClass::SPL_LONG,
				__const_Type::SPL_METHOD		=> __const_ADTClass::SPL_METHOD,
				__const_Type::SPL_NULL			=> __const_ADTClass::SPL_NULL,
				__const_Type::SPL_OBJECT		=> __const_ADTClass::SPL_OBJECT,
				__const_Type::SPL_RESOURCE		=> __const_ADTClass::SPL_RESOURCE,
				__const_Type::SPL_STRING		=> __const_ADTClass::SPL_STRING,
				__const_Type::SPL_TRAIT			=> __const_ADTClass::SPL_TRAIT
			];
			
			/**
			 * create ADT from __const_Type
			 *
			 * :rOffset<long>
			 *	offset in result-array
			 *
			 * :gcOffset<long>
			 *	zero-based index
			 *
			 * :gcType<string>
			 *	 a valid __const_Type or class-/interface-name
			 *
			 * @param	string	$__type 	{:gcType}
			 * @param	array 	$__type 	[{:rOffset} => {:gcType}]
			 * @param	array 	$__type 	[{:rOffset} => [{:gcOffset} => {:gcType}]]
			 * @return	ILLI\Core\Std\Def\Type
			 * @see		::$__def
			 * @see		ILLI\Core\Std\Def\ADT
			 * @see		ILLI\Core\Std\Def\ADTInstance
			 * @note	unlisted types: interpreting {:gcType} as class/interface and define the abstract-data-type as ADTInstance
			 */
			final public static function define($__type)
			{
				if(!is_string($__type))
				{
					if(is_array($__type))
					{
						$r = [];
						
						foreach($__type as $k => $v)
							$r[$k] = self::define($v);
						
						return $r;
					}
					
					throw new ArgumentExpectedException([
						'target'	=> __METHOD__,
						'expected'	=> 'string ILLI\Core\Std\Def\__const_Type::SPL*|string className|array [className:1, …, className:N]',
						'detected'	=> getType($v = $__type),
						'value'		=> is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
					]);
				}
				
				$n = &self::$__def[$__type];
				$a = func_get_args();
				
				if(FALSE === isset($n))
				{
					$a[0] = (array) $a[0];
					#+ instance-based ADT: ADTInstance<instanceOf myClass>
					#+ allow definition of ADT as subADT (ADT-classes are not listed as array-keys in ::$__def): ADTInstance<instanceOf ADT*>
					return Invoke::emitClass('ILLI\Core\Std\Def\ADTInstance', $a);
				}
				
				array_shift($a);
				
				#+ default ADT: ADTArray, ADTBoolean, ..., ADT*
				return Invoke::emitClass($n, $a);
			}
		#::
		
		#:gc:
			/**
			 * ADT definition gc
			 *
			 * :hashAddr<string>
			 *	absolute ADT:
			 * 		instance of get_called_class(): ILLI\Core\Std\Def\ADT*
			 *	anonymous 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}]
			 * @note	anonymous ADT: temporary gc; absolute ADT: permanent gc
			 * @note	gc[{:hashAddr}] is traversable
			 * @see		:gc:ILLI\Core\Std\Spl\Fsb:
			 */
			private static $__gc = [];
		
			/**
			 * get gc hash address
			 *
			 * @return	string
			 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_GET_NAME
			 * @see		::$__gc
			 */
			final public function getName()
			{
				try
				{
					return parent::offsetGet(0);
				}
				catch(\Exception $E)
				{
					$c = get_called_class();
					$e = $c.'\ComponentMethodCallException';
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_GET_NAME, ['method' => __METHOD__])
						: new $e($E, $e::ERROR_M_GET_NAME, ['method' => __METHOD__]);
				}
			}
		
			/**
			 * get ADT-gc
			 *
			 * @return	ILLI\Core\Std\Spl\Fsb
			 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_GET_GC
			 * @see		::$__gc
			 */
			final public function getGC()
			{
				try
				{
					return self::$__gc[$this->getName()];
				}
				catch(\Exception $E)
				{
					$c = get_called_class();
					$e = $c.'\ComponentMethodCallException';
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_GET_GC, ['method' => __METHOD__])
						: new $e($E, $e::ERROR_M_GET_GC, ['method' => __METHOD__]);
				}
			}
			
			/**
			 * join registered gc-type(s)
			 *
			 * @return	ILLI\Core\Std\Spl\Fsb
			 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_TO_STRING
			 * @see		::$__gc
			 * @see		ILLI\Core\Std\Def\__const_Type
			 */
			final public function toString()
			{
				try
				{
					return implode('|', $this->getGC()->toArray());
				}
				catch(\Exception $E)
				{
					$c = get_called_class();
					$e = $c.'\ComponentMethodCallException';
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_TO_STRING, ['method' => __METHOD__])
						: new $e($E, $e::ERROR_M_TO_STRING, ['method' => __METHOD__]);
				}
			}
		
			/**
			 * validate typedef request
			 *
			 * :offset<long>
			 *	zero-based index
			 *
			 * :gcType<string>
			 *	a valid __const_Type
			 *
			 * @param	array $__defineTypes [{:offset} => {:gcType}]
			 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
			 * @fires	ILLI\Core\Std\Exception\ArgumentExpectedException when {:gcType} is not of type string
			 * @fires	ILLI\Core\Std\Exception\ArgumentLengthZeroException when result-array is empty
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_PARSE_DEF_E_EXPECTED_STRING
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_PARSE_DEF_E_RESULT_LENGTH_ZERO
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_PARSE_DEF
			 */
			final protected function parseDef(array $__defineTypes)
			{
				$c = get_called_class();
				$e = $c.'\ComponentMethodCallException';
				
				try
				{
					$r = [];
					
					foreach($__defineTypes as $k => $v)
					{
						if(TRUE === is_string($v))
						{
							$r[$k] = $v;
							continue;
						}
						
						$E = new ArgumentExpectedException([
							'target'	=> $this->getName().'['.$k.']',
							'expected'	=> 'string', 
							'detected'	=> $t = getType($v),
							'value'		=> is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
						]);
						
						$a =
						[
							'offset'	=> $k,
							'class'		=> get_called_class()
						];
						
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, $a, ComponentMethodCallException::ERROR_M_PARSE_DEF_E_EXPECTED_STRING)
							: new $e($E, $a, $e::ERROR_M_PARSE_DEF_E_EXPECTED_STRING);
							
					}
					
					if([] !== $r)
						return $r;
					
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException(new ArgumentLengthZeroException, ['method' => __METHOD__], ComponentMethodCallException::ERROR_M_PARSE_DEF_E_RESULT_LENGTH_ZERO)
						: new $e(new ArgumentLengthZeroException, ['method' => __METHOD__], $e::ERROR_M_PARSE_DEF_E_RESULT_LENGTH_ZERO);
				}
				catch(ComponentMethodCallException $E)
				{
					throw $E;
				}
				catch(\Exception $E)
				{
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_PARSE_DEF, ['method' => __METHOD__])
						: new $e($E, $e::ERROR_M_PARSE_DEF, ['method' => __METHOD__]);
				}
			}
		
			/**
			 * Destroy anonymous ATD definitions
			 *
			 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
			 * @throws	ILLI\Core\Std\Def\ADT\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';
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_DTOR, ['method' => __METHOD__])
						: new $e($E, $e::ERROR_DTOR, ['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}]
			 * @return	string
			 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
			 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_CREATE_HASH_ADDR
			 * @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)
				{
					$c = get_called_class();
					$e = $c.'\ComponentMethodCallException';
					throw ($c === __CLASS__ || FALSE === class_exists($e))
						? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_CREATE_HASH_ADDR, ['method' => __METHOD__])
						: new $e($E, $e::ERROR_M_CREATE_HASH_ADDR, ['method' => __METHOD__]);
				}
			}
			
			#:ILLI\Core\Std\Spl\Fsb:
				#+ forward Fsb::*() to ::$__gc::*()
			
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_GET_SIZE
				 */
				final public function getSize()
				{
					try
					{
						return $this->getGC()->getSize();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_GET_SIZE, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_GET_SIZE, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_OFFSET_EXISTS
				 */
				final public function offsetExists($__offset)
				{
					try
					{
						return $this->getGC()->offsetExists($__offset);
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_OFFSET_EXISTS, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_OFFSET_EXISTS, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_OFFSET_GET
				 */
				final public function offsetGet($__offset)
				{
					try
					{
						return $this->getGC()->offsetGet($__offset);
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_OFFSET_GET, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_OFFSET_GET, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_COUNT
				 */
				final public function count()
				{
					try
					{
						return $this->getGC()->count();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_COUNT, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_COUNT, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_CURRENT
				 */
				final public function current()
				{
					try
					{
						return $this->getGC()->current();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_CURRENT, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_CURRENT, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_KEY
				 */
				final public function key()
				{
					try
					{
						return $this->getGC()->key();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_KEY, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_KEY, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_NEXT
				 */
				final public function next()
				{
					try
					{
						return $this->getGC()->next();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_NEXT, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_NEXT, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_REWIND
				 */
				final public function rewind()
				{
					try
					{
						return $this->getGC()->rewind();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_REWIND, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_REWIND, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_VALID
				 */
				final public function valid()
				{
					try
					{
						return $this->getGC()->valid();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_VALID, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_VALID, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_END
				 */
				final public function end()
				{
					try
					{
						return $this->getGC()->end();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_END, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_END, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_KEYS
				 */
				final public function keys()
				{
					try
					{
						return $this->getGC()->keys();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_KEYS, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_KEYS, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_PREV
				 */
				final public function prev()
				{
					try
					{
						return $this->getGC()->prev();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_PREV, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_PREV, ['method' => __METHOD__]);
					}
				}
				
				/**
				 * @return	integer
				 * @catchable	ILLI\Core\Std\Def\ADT\ComponentMethodCallException
				 * @throws	ILLI\Core\Std\Def\ADT\ComponentMethodCallException::ERROR_M_VALUES
				 */
				final public function values()
				{
					try
					{
						return $this->getGC()->values();
					}
					catch(\Exception $E)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_VALUES, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_VALUES, ['method' => __METHOD__]);
					}
				}
			
				#:NotSupported:
					#! disable Fsb element modifiers
					
					/**
					 * @notSupported
				 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
					 */
					final public function setSize($__size)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						$E = new NotSupportedException(['target' => __METHOD__]);
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_SET_SIZE, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_SET_SIZE, ['method' => __METHOD__]);
					}
					
					/**
					 * @notSupported
				 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
					 */
					final public function offsetSet($__offset, $__value)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						$E = new NotSupportedException(['target' => __METHOD__]);
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_OFFSET_SET, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_OFFSET_SET, ['method' => __METHOD__]);
					}
					
					/**
					 * @notSupported
				 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
					 */
					final public function offsetUnset($__offset)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						$E = new NotSupportedException(['target' => __METHOD__]);
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_OFFSET_UNSET, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_OFFSET_UNSET, ['method' => __METHOD__]);
					}
					
					/**
					 * @notSupported
				 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
					 */
					final public static function fromArray($__array, $__saveIndexes = TRUE)
					{
						$c = get_called_class();
						$e = $c.'\ComponentMethodCallException';
						$E = new NotSupportedException(['target' => __METHOD__]);
						throw ($c === __CLASS__ || FALSE === class_exists($e))
							? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_M_FROM_ARRAY, ['method' => __METHOD__])
							: new $e($E, $e::ERROR_M_FROM_ARRAY, ['method' => __METHOD__]);
					}
				#::
			#::
		#::
		
		#:deprecated:
			/**
			 * @deprecated
			 */
			final protected function mergeTypes(array $__definedTypes, array $__defineTypes)
			{
					throw new NotSupportedException([
						'target' => __METHOD__
					]);
				$a = func_get_args();
				$r = [];
				
				foreach($a as $t)
				{
					foreach($t as $k => $v)
					{
						if(FALSE === is_integer($k))
							throw new ArgumentExpectedException([
								'target'	=> get_called_class().'['.$k.']',
								'expected'	=> 'integer',
								'detected'	=> $t = getType($v),
								'value'		=> is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
							]);
							
						if(isset($r[$k]))
							throw new ArgumentInUseException([
								'target' => get_called_class().'['.$k.']'
							]);
							
						$r[$k] = $v;
					}
				}
				
				return $r;
			}
		#::
	}