<?php
/**
* ファクトリクラス
*
* PHP version 5
*
* @package    core
* @author     stk2k <stk2k@sazysoft.com>
* @copyright  2008 stk2k, sazysoft
*/

class Factory
{
	/*
	 * キャッシュファイルを作成
	 */
	public static function createCacheFile( $cache_file_name, $data = NULL )
	{
		log_info( "system",  "キャッシュファイル[$cache_file_name]をロードします。", __FILE__, __LINE__ );

		// キャッシュファイル設定ファイルの読み込み
		$cache_file_config = ConfigLoader::loadConfig( $cache_file_name, "cache_file" );

		// キャッシュファイルのインスタンス生成
		$cache_file = new CacheFile( $cache_file_name, $data );

		log_info( "system",  "キャッシュファイル[$cache_file_name]を初期化します。", __FILE__, __LINE__ );

		// キャッシュファイルを初期化
		$cache_file->initCacheFile( $cache_file_config );

		log_info( "system",  "キャッシュファイル[$cache_file_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたキャッシュファイルを返却
		return $cache_file;
	}

	/*
	 *    クラスローダを作成
	 */
	public static function createClassLoader( $class_loader_name )
	{
		log_info( "system",  "クラスローダ[$class_loader_name]を作成します。", __FILE__, __LINE__ );

		// 設定プロバイダを作成
		$provider = Factory::createConfigProvider();

		// 設定値格納用オブジェクトを作成
		$config= new Config();

		// 設定ルートパス
		$config_root_webapp = ResourceLocator::getWebAppPath('config');
		$config_root_system = ResourceLocator::getSystemPath('config');

		// 個別設定ファイルを読み込む
		$config_name = "class_loaders/$class_loader_name.class_loader";
		$config->append( $provider->load( $config_root_webapp, $config_name ) );
		$config->append( $provider->load( $config_root_system, $config_name ) );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		if ( !$class_name ){
			throw new ClassLoaderConfigException( 'class_name', 'mandatory' );
		}

		// ソースパスを取得
		$source_file = $config->getString( 'source_file' );

		if ( !$source_file ){
			throw new ClassLoaderConfigException( 'source_file', 'mandatory' );
		}

		// ソースの取り込み
		require_once( "$source_file" );

		// クラスローダのインスタンス生成
		$classloader = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIClassLoaderインタフェースを実装しているか確認
		if ( !($classloader instanceof IClassLoader) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IClassLoader" );
		}

		log_info( "system",  "クラスローダ[$class_loader_name]を作成しました。", __FILE__, __LINE__ );

		// ロードしたクラスローダを返却
		return $classloader;
	}

	/*
	 * 設定を作成
	 */
	public static function createConfigProvider()
	{
//		log_info( "system",  "設定プロバイダをロードします。", __FILE__, __LINE__ );

		// 設定プロバイダクラス名
		$class_name = Profile::getString( 'CONFIG_PROVIDER_CLASS' );

		// 未設定をチェック
		if ( !$class_name ){
			throw new ProfileException( "CONFIG_PROVIDER_CLASS", "mandatory" );
		}

		// 設定プロバイダのインスタンス生成
		$provider = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIConfigProviderインタフェースを実装しているか確認
		if ( !($provider instanceof IConfigProvider) ){
			// provider
			throw new InterfaceImplementException( $class_name, "IConfigProvider" );
		}

//		log_info( "system",  "設定プロバイダをロードしました。", __FILE__, __LINE__ );

		// ロードした設定プロバイダを返却
		return $provider;
	}

	/*
	 * データソースを作成
	 */
	public static function createDataSource( $data_source_name )
	{
		log_info( "system",  "データソース[$data_source_name]をロードします。", __FILE__, __LINE__ );

		// Configをロード
		$config = ConfigLoader::loadConfig( $data_source_name, "data_source" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// データソースのインスタンス生成
		$data_source = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIValidatorインタフェースを実装しているか確認
		if ( !($data_source instanceof IDataSource) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IDataSource" );
		}

		log_info( "system",  "データソース[$data_source_name]を初期化します。", __FILE__, __LINE__ );

		// データソースを初期化
		$data_source->init( $config );

		log_info( "system",  "データソース[$data_source_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたデータソースを返却
		return $data_source;
	}

	/*
	 * イベントを作成
	 */
	public static function createEvent( $event_name, IRequest $request )
	{
		log_info( "system",  "イベント[$event_name]をロードします。", __FILE__, __LINE__ );

		// ValidatorConfigをロード
		$event_config = ConfigLoader::loadConfig( $event_name, "event" );

		// クラス名を取得
		$class_name = $event_config->getString( "class_name" );

		// イベントのインスタンス生成
		$event = ClassUtil::newInstance( $class_name, $request );

		// 生成したインスタンスがIEventインタフェースを実装しているか確認
		if ( !($event instanceof IEvent) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IEvent" );
		}

		log_info( "system",  "イベント[$event_name]を初期化します。", __FILE__, __LINE__ );

		// イベントを初期化
		$event->init( $event_config );

		log_info( "system",  "イベント[$event_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたイベントを返却
		return $event;
	}

	/*
	 * フィルタを作成
	 */
	public static function createFilter( $filter_name )
	{
		log_info( "system",  "フィルタ[$filter_name]をロードします。", __FILE__, __LINE__ );

		// FilterConfigをロード
		$config = ConfigLoader::loadConfig( $filter_name, 'filter' );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		// フィルタのインスタンス生成
		$filter = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIFilterインタフェースを実装しているか確認
		if ( !($filter instanceof IFilter) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IFilter" );
		}

		log_info( "system",  "フィルタ[$filter_name]を初期化します。", __FILE__, __LINE__ );

		// フィルタを初期化
		$filter->init( $config );

		log_info( "system",  "フィルタ[$filter_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたフィルタを返却
		return $filter;
	}

	/*
	 * フォームを作成
	 */
	public static function createForm( $form_name )
	{
		log_info( "system",  "フォーム[$form_name]をロードします。", __FILE__, __LINE__ );

		// FormConfigをロード
		$config = ConfigLoader::loadConfig( $form_name, "form" );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		// フォームのインスタンス生成
		$form = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIformインタフェースを実装しているか確認
		if ( !($form instanceof IForm) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IForm" );
		}

		log_info( "system",  "フォーム[$form_name]を初期化します。", __FILE__, __LINE__ );

		// フォームを初期化
		$form->init( $config );

		log_info( "system",  "フォーム[$form_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたフォームを返却
		return $form;
	}

	/*
	 * レイアウトマネージャを作成
	 */
	public static function createLayoutManager( $layout_manager_name )
	{
		log_info( "system",   "レイアウトマネージャ[$layout_manager_name]をロードします。", __FILE__, __LINE__ );

		// DispatcherConfigをロード
		$config = ConfigLoader::loadConfig( $layout_manager_name, "layout_manager" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// レイアウトマネージャのインスタンス生成
		$layout_manager = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがILayoutManagerインタフェースを実装しているか確認
		if ( !($layout_manager instanceof ILayoutManager) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ILayoutManager" );
		}

		log_info( "system",   "レイアウトマネージャ[$layout_manager_name]を初期化します。", __FILE__, __LINE__ );

		// レイアウトマネージャを初期化
		$layout_manager->init( $config );

		log_info( "system",   "レイアウトマネージャ[$layout_manager_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたレイアウトマネージャを返却
		return $layout_manager;
	}

	/*
	 * ロガーを作成
	 */
	public static function createLogger( $logger_name )
	{
		if ( strlen("$logger_name") == 0 ){
			throw new ParameterException();
		}

		// 設定プロバイダを作成
		$provider = Factory::createConfigProvider();

		// 設定値格納用オブジェクトを作成
		$config= new Config();

		// 設定ルートパス
		$config_root_webapp = ResourceLocator::getWebAppPath('config');
		$config_root_system = ResourceLocator::getSystemPath('config');

		// 個別設定ファイルを読み込む
		$config_name = "loggers/$logger_name.logger";
		$config->append( $provider->load( $config_root_webapp, $config_name ) );
		$config->append( $provider->load( $config_root_system, $config_name ) );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		// クラス名の確認
		if ( !$class_name || !ClassUtil::validateClassName($class_name) ){
			throw new LoggerConfigException( 'class_name', "invalid class name:$class_name" );
		}

		// ロガーのインスタンス生成
		$logger = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがILoggerインタフェースを実装しているか確認
		if ( !($logger instanceof ILogger) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ILogger" );
		}

		// ロガーを初期化
		$logger->init( $config );

		// ロードしたロガーを返却
		return $logger;
	}

	/*
	 * モジュールを作成
	 */
	public static function createModule( $module_name )
	{
		log_info( "system",  "モジュール[$module_name]をロードします。", __FILE__, __LINE__ );

		// モジュール設定ファイルの読み込み
		$config = ConfigLoader::loadConfig( $module_name, 'module' );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		// モジュールのインスタンス生成
		$module = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIModuleインタフェースを実装しているか確認
		if ( !($module instanceof IModule) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IModule" );
		}

		log_info( "system",  "モジュール[$module_name]を初期化します。", __FILE__, __LINE__ );

		// モジュールを初期化
		$module->init( $config );

		log_info( "system",  "モジュール[$module_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたモジュールを返却
		return $module;
	}

	/*
	 * プロシージャを作成
	 */
	public static function createProcedure( $proc_key )
	{
		log_info( "system",  "プロシージャ[$proc_key]を作成します。", __FILE__, __LINE__ );

		// proc_list.iniを読み込む
		$config_file = ResourceLocator::getWebAppPath( 'config', "proc_list.ini" );
		if ( is_file($config_file) ){
			$proc_list = parse_ini_file($config_file,FALSE);
		}
		else{
			$proc_list = array();
		}
		
		// 登録されていないキーが指定された場合は404
		if ( !isset($proc_list[ "$proc_key" ]) ){
			log_error( 'system,error', "登録されていないプロシージャキーです:$proc_key", __FILE__, __LINE__ );
			throw new HttpException( 404 );
		}

		// プロシージャキーからプロシージャ名に変換
		$proc_name = $proc_list[ "$proc_key" ];

		// ProcedureConfigをロード
		$config = ConfigLoader::loadConfig( $proc_name, "procedure" );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		if ( !$class_name ){
			throw new ProcedureConfigException( $proc_name, 'class_name' );
		}

		// プロシージャのインスタンス生成
		$procedure = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIprocedureインタフェースを実装しているか確認
		if ( !($procedure instanceof IProcedure) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IProcedure" );
		}

		log_info( "system",  "プロシージャ[$proc_key]を初期化します。", __FILE__, __LINE__ );

		// プロシージャを初期化
		$procedure->init( $config );

		log_info( "system",  "プロシージャ[$proc_key]を作成しました。", __FILE__, __LINE__ );

		// プロシージャ、プロシージャ名を返却
		return array( $procedure, $proc_name );
	}

	/*
	 * レンダラーを作成
	 */
	public static function createRenderer( $renderer_name )
	{
		log_info( "system",  "レンダラー[$renderer_name]をロードします。", __FILE__, __LINE__ );

		// RendererConfigをロード
		$config = ConfigLoader::loadConfig( $renderer_name, 'renderer' );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		// レンダラーのインスタンス生成
		$renderer = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIRendererインタフェースを実装しているか確認
		if ( !($renderer instanceof IRenderer) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IRenderer" );
		}

		log_info( "system",  "レンダラー[$renderer_name]を初期化します。", __FILE__, __LINE__ );

		// レンダラーを初期化
		$renderer->init( $config );

		log_info( "system",  "レンダラー[$renderer_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたレンダラーを返却
		return $renderer;
	}

	/*
	 * リソースを作成
	 */
	public static function createResource( $resource_name )
	{
		log_info( 'system', "リソース[$resource_name]をロードします。", __FILE__, __LINE__ );

		// リソース設定ファイルの読み込み
		$config = ConfigLoader::loadConfig( $resource_name, 'resource' );

		// クラス名を取得
		$class_name = $config->getString( 'class_name' );

		// リソースのインスタンス生成
		$resource = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIResourceインタフェースを実装しているか確認
		if ( !($resource instanceof IResource) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IResource" );
		}

		log_info( 'system',  "リソース[$resource_name]を初期化します。", __FILE__, __LINE__ );

		// リソースを初期化
		$resource->init( $config );

		log_info( 'system', "リソース[$resource_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたリソースを返却
		return $resource;
	}

	/*
	 * セッションハンドラを作成
	 */
	public static function createSessionHandler( $session_handler_name )
	{
		log_info( "system",  "セッションハンドラ[$session_handler_name]をロードします。", __FILE__, __LINE__ );

		// session_handlerConfigをロード
		$config = ConfigLoader::loadConfig( $session_handler_name, "session_handler" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// セッションハンドラのインスタンス生成
		$session_handler = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIsession_handlerインタフェースを実装しているか確認
		if ( !($session_handler instanceof ISessionHandler) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ISessionHandler" );
		}

		log_info( "system",  "セッションハンドラ[$session_handler_name]を初期化します。", __FILE__, __LINE__ );

		// セッションハンドラを初期化
		$session_handler->init( $config );

		ini_set('session.save_handler', 'user');

		// セッションハンドラのコールバック関数を登録
		session_set_save_handler(
					array( "$class_name", 'open' ), 
					array( "$class_name", 'close' ), 
					array( "$class_name", 'read' ), 
					array( "$class_name", 'write' ), 
					array( "$class_name", 'destroy' ), 
					array( "$class_name", 'gc' )
			);

		log_info( "system",  "セッションハンドラ[$session_handler_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたセッションハンドラを返却
		return $session_handler;
	}

	/*
	 * SQLビルダを作成
	 */
	public static function createSQLBuilder( $builder_name )
	{
		log_info( "system",  "SQLビルダ[$builder_name]をロードします。", __FILE__, __LINE__ );

		// builderConfigをロード
		$config = ConfigLoader::loadConfig( $builder_name, "sql_builder" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// SQLビルダのインスタンス生成
		$builder = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIbuilderインタフェースを実装しているか確認
		if ( !($builder instanceof ISQLBuilder) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ISQLBuilder" );
		}

		log_info( "system",  "SQLビルダ[$builder_name]を初期化します。", __FILE__, __LINE__ );

		// SQLビルダを初期化
		$builder->init( $config );

		log_info( "system",  "SQLビルダ[$builder_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたSQLビルダを返却
		return $builder;
	}

	/*
	 * テーブルモデルを作成
	 */
	public static function createTableModel( $table_model_name )
	{
		log_info( "system",  "テーブルモデル[$table_model_name]をロードします。", __FILE__, __LINE__ );

		// Configをロード
		$config = ConfigLoader::loadConfig( $table_model_name, "table_model" );

		// 必須項目のチェック
		if ( !$config->keyExists("class_name") ){
			throw new TableModelConfigException( $table_model_name, "[class_name] is mandatory" );
		}

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// テーブルモデルのインスタンス生成
		$table_model = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがITableModelインタフェースを実装しているか確認
		if ( !($table_model instanceof ITableModel) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ITableModel" );
		}

		// モデルIDを設定
		$table_model->setModelID( $table_model_name );

		log_info( "system",  "テーブルモデル[$table_model_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたテーブルモデルを返却
		return $table_model;
	}

	/*
	 * タスクマネージャを作成
	 */
	public static function createTaskManager( $task_manager_name )
	{
		log_info( "system",   "タスクマネージャ[$task_manager_name]をロードします。", __FILE__, __LINE__ );

		// DispatcherConfigをロード
		$config = ConfigLoader::loadConfig( $task_manager_name, "task_manager" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// タスクマネージャのインスタンス生成
		$task_manager = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがITaskManagerインタフェースを実装しているか確認
		if ( !($task_manager instanceof ITaskManager) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ITaskManager" );
		}

		log_info( "system",   "タスクマネージャ[$task_manager_name]を初期化します。", __FILE__, __LINE__ );

		// タスクマネージャを初期化
		$task_manager->init( $config );

		log_info( "system",   "タスクマネージャ[$task_manager_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたタスクマネージャを返却
		return $task_manager;
	}

	/*
	 * トランスフォーマを作成
	 */
	public static function createTransformer( $transformer_name )
	{
		log_info( "system",  "トランスフォーマ[$transformer_name]をロードします。", __FILE__, __LINE__ );

		// Configをロード
		$config = ConfigLoader::loadConfig( $transformer_name, "transformer" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// トランスフォーマのインスタンス生成
		$transformer = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIValidatorインタフェースを実装しているか確認
		if ( !($transformer instanceof ITransformer) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ITransformer" );
		}

		log_info( "system",  "トランスフォーマ[$transformer_name]を初期化します。", __FILE__, __LINE__ );

		// トランスフォーマを初期化
		$transformer->init( $config );

		log_info( "system",  "トランスフォーマ[$transformer_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたトランスフォーマを返却
		return $transformer;
	}

	/*
	 * URLマッパーを作成
	 */
	public static function createURLMapper( $url_mapper_name )
	{
		log_info( "system",  "URLマッパー[$url_mapper_name]をロードします。", __FILE__, __LINE__ );

		// Configをロード
		$config = ConfigLoader::loadConfig( $url_mapper_name, "url_mapper" );

		// 必須項目のチェック
		if ( !$config->keyExists("class_name") ){
			throw new URLMapperConfigException( $url_mapper_name, "[class_name] is mandatory" );
		}

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// URLマッパーのインスタンス生成
		$url_mapper = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIValidatorインタフェースを実装しているか確認
		if ( !($url_mapper instanceof IURLMapper) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IURLMapper" );
		}

		log_info( "system",  "URLマッパー[$url_mapper_name]を初期化します。", __FILE__, __LINE__ );

		// URLマッパーを初期化
		$url_mapper->init( $config );

		log_info( "system",  "URLマッパー[$url_mapper_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたURLマッパーを返却
		return $url_mapper;
	}

	/*
	 * バリデータを作成
	 */
	public static function createValidator( $validator_name )
	{
		Logger::writeln( LogLevel::INFO,  "バリデータ[$validator_name]をロードします。", __FILE__, __LINE__ );

		// ValidatorConfigをロード
		$validator_config = ConfigLoader::loadConfig( $validator_name, "validator" );

		// クラス名を取得
		$class_name = $validator_config->getString( "class_name" );

		// バリデータのインスタンス生成
		$validator = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIValidatorインタフェースを実装しているか確認
		if ( !($validator instanceof IValidator) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IValidator" );
		}

		Logger::writeln( LogLevel::INFO,  "バリデータ[$validator_name]を初期化します。", __FILE__, __LINE__ );

		// バリデータを初期化
		$validator->initValidator( $validator_config );

		Logger::writeln( LogLevel::INFO,  "バリデータ[$validator_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたバリデータを返却
		return $validator;
	}

	/*
	 * リクエストを作成
	 */
	public static function createRequest( $request_name )
	{
		log_info( "system",  "リクエスト[$request_name]をロードします。", __FILE__, __LINE__ );

		// Configをロード
		$config = ConfigLoader::loadConfig( $request_name, "request" );

		// クラス名を取得
		$class_name = $config->getString( "class_name" );

		// リクエストのインスタンス生成
		$request = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがIRequestインタフェースを実装しているか確認
		if ( !($request instanceof IRequest) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "IRequest" );
		}

		log_info( "system",  "リクエスト[$request_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたリクエストを返却
		return $request;
	}

	/*
	 * タスクを作成
	 */
	public static function createTask( $task_name )
	{
		log_info( "system",  "タスク[$task_name]をロードします。", __FILE__, __LINE__ );

		// ValidatorConfigをロード
		$task_config = ConfigLoader::loadConfig( $task_name, "task" );

		// クラス名を取得
		$class_name = $task_config->getString( "class_name" );

		// タスクのインスタンス生成
		$task = ClassUtil::newInstance( $class_name );

		// 生成したインスタンスがITaskインタフェースを実装しているか確認
		if ( !($task instanceof ITask) ){
			// 実装例外
			throw new InterfaceImplementException( $class_name, "ITask" );
		}

		log_info( "system",  "タスク[$task_name]を初期化します。", __FILE__, __LINE__ );

		// タスクを初期化
		$task->init( $task_config );

		log_info( "system",  "タスク[$task_name]をロードしました。", __FILE__, __LINE__ );

		// ロードしたタスクを返却
		return $task;
	}
}
