<?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\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 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
		 * @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
		 * @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
		 * @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
		 * @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}]
		 * @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 a string
		 */
		protected function parseDef(array $__defineTypes)
		{
			try
			{
				$r = [];
				
				foreach($__defineTypes as $k => $v)
				{
					if(FALSE === is_string($v))
						throw new ArgumentExpectedException([
							'target'	=> $this->getName().'['.$k.']',
							'expected'	=> 'string',
							'detected'	=> $t = getType($v),
							'value'		=> is_object($v)
										? get_class($v)
										: ((is_string($v) && (class_exists($v) || interface_exists($v))) || is_scalar($v)) ? $v : $t
						]);
						
					$r[$k] = $v;
				}
				
				if([] === $r)
					throw new ArgumentLengthZeroException;
				
				return $r;
			}
			catch(\Exception $E)
			{
				throw new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_PARSE_DEF, ['method' => __METHOD__]);
			}
		}
		
		#:ILLI\Core\Std\Spl\Fsb:
			#:NotSupported:
			/**
			 * @notSupported
		 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
			 */
			public function setSize($__size)
			{
				throw new NotSupportedException([
					'target' => __METHOD__
				]);
			}
			
			/**
			 * @notSupported
		 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
			 */
			public function offsetSet($__offset, $__value)
			{
				throw new NotSupportedException([
					'target' => __METHOD__
				]);
			}
			
			/**
			 * @notSupported
		 	 * @throws	ILLI\Core\Std\Exception\NotSupportedException
			 */
			public function offsetUnset($__offset)
			{
				throw new NotSupportedException([
					'target' => __METHOD__
				]);
			}
			#::
			
			#:gc:
			public function getSize()
			{
				return $this->getGC()->getSize();
			}
			
			public function offsetGet($__offset)
			{
				return $this->getGC()->offsetGet($__offset);
			}
			
			public function offsetExists($__offset)
			{
				return $this->getGC()->offsetExists($__offset);
			}
			
			public function rewind()
			{
				return $this->getGC()->rewind();
			}
			
			public function end()
			{
				return $this->getGC()->end();
			}
			
			public function valid()
			{
				return $this->getGC()->valid();
			}
			
			public function current()
			{
				return $this->getGC()->current();
			}
			
			public function key()
			{
				return $this->getGC()->key();
			}
			
			public function prev()
			{
				return $this->getGC()->prev();
			}
			
			public function next()
			{
				return $this->getGC()->next();
			}
			
			public function count()
			{
				return $this->getGC()->count();
			}
			
			public function keys()
			{
				return $this->getGC()->keys();
			}
			
			public function values()
			{
				return $this->getGC()->values();
			}
			#::
		#::
	}