<?PHP
	NAMESPACE ILLI\Core\Std;
	USE ILLI\Core\Std\Exception\ArgumentExpectedException;
	USE ILLI\Core\Std\Def\__const_ADTClass;
	USE ILLI\Core\Std\Def\__const_ADVClass;
	USE ILLI\Core\Std\Def\__const_Type;
	USE ILLI\Core\Std\Def\ADTInstance;
	USE ILLI\Core\Std\Def\ADVInstance;
	
	/**
	 * builder for Abstract Data Types (ADT) and ADT-based type-value-pairs (ADV)
	 */
	FINAL CLASS Def EXTENDS \ILLI\Core\Std\StaticClass
	{
		#:ADT:
			#:mapping:
			/**
			 * ADT class-mapping
			 *
			 * :gcType<string>
			 *	a valid __const_Type
			 *
			 * :adtClass<string>
			 *	- ILLI\Core\Std\Def\ADT*
			 *
			 * @var		array [{:gcType} => {:adtClass}]
			 * @see		::type()
			 * @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 ::type()
			 */
			private static $__adt = 
			[
				__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,
				__const_Type::SPL_TUPLE			=> __const_ADTClass::SPL_TUPLE
			];
			#::
			
			#:builder:
			/**
			 * create ADT
			 *
			 * :offset<long>
			 *	zero-based index
			 *
			 * :gcType<string>
			 *	 a valid __const_Type or class-/interface-name
			 *
			 * @param	string	$__type 	{:gcType}
			 * @param	array 	$__type 	[{:offset} => {:gcType}] 
			 * @return	ILLI\Core\Std\Def\Type
			 * @see		::$__adt
			 * @see		ILLI\Core\Std\Def\ADTInstance
			 * @note	unlisted types: interpreting {:gcType} as class/interface and define the abstract-data-type as ADTInstance
			 */
			public static function type($__type)
			{
				if(is_array($__type))
					return new ADTInstance($__type);
				
				if(!is_string($__type))
					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_string($v) && (class_exists($v) || interface_exists($v))) || is_scalar($v)) ? $v : $t
					]);
				
				$n = &self::$__adt[$__type];
				
				return isset($n)
					? new $n
					: new ADTInstance([$__type]);
			}
			#::
		#::
		
		#:ADV:
			#:mapping:
			/**
			 * ADV class-mapping
			 *
			 * :gcType<string>
			 *	a valid __const_Type
			 *
			 * :advClass<string>
			 *	- ILLI\Core\Std\Def\ADV*
			 *
			 * @var		array [{:type} => {:advClass}]
			 * @see		::value()
			 * @see		ILLI\Core\Std\Def\__const_ADVClass
			 * @see		ILLI\Core\Std\Def\__const_Type
			 * @note	you can not define a NULL-value-pair
			 * @note	ILLI\Core\Std\Def\__const_ADVClass::SPL_INSTANCE will be created by ::value()
			 */
			private static $__adv = 
			[
				__const_Type::SPL_ARRAY			=> __const_ADVClass::SPL_ARRAY,
				__const_Type::SPL_BOOLEAN		=> __const_ADVClass::SPL_BOOLEAN,
				__const_Type::SPL_CALLABLE		=> __const_ADVClass::SPL_CALLABLE,
				__const_Type::SPL_CLASS			=> __const_ADVClass::SPL_CLASS,
				__const_Type::SPL_CLOSURE		=> __const_ADVClass::SPL_CLOSURE,
				__const_Type::SPL_DIRECTORY		=> __const_ADVClass::SPL_DIRECTORY,
				__const_Type::SPL_DOUBLE		=> __const_ADVClass::SPL_DOUBLE,
				__const_Type::SPL_FILE			=> __const_ADVClass::SPL_FILE,
				__const_Type::SPL_FLOAT			=> __const_ADVClass::SPL_DOUBLE,
				__const_Type::SPL_FUNCTION		=> __const_ADVClass::SPL_FUNCTION,
				__const_Type::SPL_INTERFACE		=> __const_ADVClass::SPL_INTERFACE,
				__const_Type::SPL_INTEGER		=> __const_ADVClass::SPL_LONG,
				__const_Type::SPL_LONG			=> __const_ADVClass::SPL_LONG,
				__const_Type::SPL_METHOD		=> __const_ADVClass::SPL_METHOD,
				__const_Type::SPL_OBJECT		=> __const_ADVClass::SPL_OBJECT,
				__const_Type::SPL_RESOURCE		=> __const_ADVClass::SPL_RESOURCE,
				__const_Type::SPL_STRING		=> __const_ADVClass::SPL_STRING,
				__const_Type::SPL_TRAIT			=> __const_ADVClass::SPL_TRAIT,
				__const_Type::SPL_TUPLE			=> __const_ADVClass::SPL_TUPLE
			];
			#::
			
			#:builder:
			/**
			 * create ADV
			 *
			 * :gcType<string>
			 *	 a valid __const_Type or class-/interface-name
			 *
			 * @param	string $__type {:gcType}
			 * @return	ILLI\Core\Std\Def\ADV
			 * @see		::$__adv
			 * @see		ILLI\Core\Std\Def\ADVInstance
			 * @note	unlisted types: interpreting {:gcType} as class/interface and define the type-value-pair as ADVInstance
			 */
			public static function value($__type)
			{
				if(!is_string($__type))
					throw new ArgumentExpectedException([
						'target'	=> __METHOD__,
						'expected'	=> 'string ILLI\Core\Std\Def\__const_Type::SPL*',
						'detected'	=> getType($v = $__type),
						'value'		=> is_object($v)
									? get_class($v)
									: ((is_string($v) && (class_exists($v) || interface_exists($v))) || is_scalar($v)) ? $v : $t
					]);
				
				$n = &self::$__adv[$__type];
				
				return isset($n)
					? new $n($__type)
					: new ADVInstance($__type);
			}
			#::
		#::
	}