/*
このファイルの中身は、NTT オープンソースライセンス　バージョン 1.0（「本
契約」という）の適用を受けます。
本契約を遵守しない限り、このファイルを使用してはなりません。
本契約のコピーは、次のＵＲＬから入手できます。
【配布サイトのURL】 http://www.oss.ecl.ntt.co.jp/lms/

本契約に基づき頒布されるソフトウェアは、現状のまま、明示又は黙示のあらゆ
る種類の保証なしで、頒布されます。本契約に基づく権利及び制限を律する特定
の文言については、本契約を参照してください。

「オリジナルコード」は、 NTT Cyber Space Laboratories Code です。 
「オリジナルコード」の「初期開発者」は、日本電信電話株式会社です。  
日本電信電話株式会社により創作された部分は、Copyright (C) 2004 
日本電信電話株式会社 です。
全ての権利が留保されます。 
「コントリビュータ」：_____________________________________ 


The contents of this file are subject to the NTT Opensource License
Version 1.0 (the License); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
【配布サイトのURL】 http://www.oss.ecl.ntt.co.jp/lms/

Software distributed under the License is distributed on an AS IS
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
License for the specific language governing rights and limitations
under the License.

The Original Code is NTT Cyber Space Laboratories Code .

The Initial Developer of the Original Code is NIPPON TELEGRAPH AND 
TELEPHONE CORPORATION.
Portions created by the NIPPON TELEGRAPH AND TELEPHONE CORPORATION 
are Copyright (C) 2004 NIPPON TELEGRAPH AND TELEPHONE CORPORATION. 
All Rights Reserved.

Contributor(s) ______________________________________.
*/

//
//機能名称 
//			CMI プロトタイプ　クラス
//	変更履歴
//				2003.11.24	zcj  新規作成		
//
package jp.co.ntt.lms.lo.scorm.cbtcom;

import java.util.Vector;

/**
 * CMI プロトタイプ　クラス
 *
 * @author lcg
 *
 */
public class CMIElementProto {
	
	/**
	 * g_cbt オブジェクトのプロトタイプ
	 */
	public static CMIElementProto g_cbtProto = null;
   
	/**
	 * launch オブジェクトのプロトタイプ
	 */
	public static CMIElementProto g_launchProto = null;
	
	/**
	 * g_lesson オブジェクトのプロトタイプ
	 */
	public static CMIElementProto g_lessonProto = null;
	
	/**
	 * g_evaluation オブジェクトのプロトタイプ
	 */
	public static CMIElementProto g_evaluationProto = null;
	
	/**
	 * g_g_cbt オブジェクトのプロトタイプ
	 */
	public static CMIElementProto g_g_cbtProto = null;
	
	/**
	 * バージョン区分(true:グローバルバージョン)
	 */
	public static boolean IS_GLOBAL_MEM = false;
   	
	/**
	 * 初期化直前処理のオブジェクト
	 */
	private IBeforeInitializer beforeInitializer = null;
	
	/**
	 * 初期化処理のオブジェクト
	 */
	private IInitializer initializer = null;
	
	/**
	 * PutParam処理のオブジェクト
	 */
	private IMaintenancePutParam maintenancePutParam = null;
	
	/**
	 * GetParam処理のオブジェクト
	 */
	private IMaintenanceGetParam maintenanceGetParam = null;
	
	/**
	 * SetValue処理のオブジェクト
	 */
	private IMaintenanceSetValue maintenanceSetValue = null;
   	
	/**
	 * GetValue処理のオブジェクト
	 */
	private IMaintenanceGetValue maintenanceGetValue = null;
	
	/**
	 * GetPutParam処理のオブジェクト
	 */
	private IMaintenanceGetPutParam maintenanceGetPutParam = null;
   
	/**
	 * 名称
	 */
	private String name = null;
   	
	/**
	 * グローバルパラメータ(インスタンス間で共有する）
	 */
	private boolean isGlobal = false;
	/**
	 * セッション初期化タイプ(セッション初期化処理）
	 */
	private boolean isSession = false;
   /**
    * 終端の要素のとき true
    */
   private boolean isLeaf = false;
   /**
    * 配列のとき true
    */
   private boolean isArray = false;
   /**
    * get可能のとき true
    */
   private boolean isReadable = false;
   /**
    * set可能のとき true
    */
   private boolean isWriteable = false;
   /**
    * getAllValue/setAllValueの対象
    */
   private boolean isSerializable = false;
   /**
    * 必須項目のとき true
    */
   private boolean isMandatory = false;
   /**
    * 値のデータ型
    */
   private int valueType;
   /**
    * 空値を許すとき true
    */
   private boolean canBeBlank = false;
   /**
    * メンバ定義テーブル
    */
   private Vector memberTable = null;
   /**
    * putParam/getParam name
    */
	private String keyWord = null;
	/**
	 * デフォルトデータ
	 */
	private String defaultData = null;
	/**
	 * SCORM1.3規格時のモデル名
	 */
	private String scormName = null;
   
	public static final int CMINoType = 0;
	public static final int CMIBlank = 1;
	public static final int CMIBoolean = 2;
	public static final int CMIDate = 3;
	public static final int CMIFeedback = 4;
	public static final int CMIDecimal = 5;
	public static final int CMIIdentifier = 6;
	public static final int CMILocale = 7;
	public static final int CMIInteger = 8;
	public static final int CMISIdentifier = 9;
	public static final int CMISInteger = 10;
	public static final int CMIString256 = 11;
	public static final int CMIString4096 = 12;
	public static final int CMITime = 13;
	public static final int CMITimespan = 14;
	public static final int CMIVocabulary = 15;
	public static final int CMIString1000 = 16;
	public static final int CMI_CLS_CBT = 1;
	public static final int CMI_CLS_LA = 2;
	public static final int CMI_CLS_LS = 4;
	public static final int CMI_CLS_ED = 8;


	static {
		init();
	}
   /**
    * CMIElementProtoクラスのコンストラクタ<br>
    */
   public CMIElementProto() {

	//初期化直前処理のオブジェクト
	beforeInitializer = null;
	  
	//初期化処理のオブジェクト
	initializer = null;
	  
	//PutParam処理のオブジェクト
	maintenancePutParam = null;
	
	//GetParam処理のオブジェクト
	maintenanceGetParam = null;
	
	//SetValue処理のオブジェクト
	maintenanceSetValue = null;
	
	//GetValue処理のオブジェクト
	maintenanceGetValue = null;
	
	//GetPutParam処理のオブジェクト
	maintenanceGetPutParam = null;
	
	//名称
	name = null;
	
	//ローバルパラメータ(インスタンス間で共有する）
	isGlobal = false;
	
	//ッション初期化タイプ(セッション初期化処理）
	isSession = false;
	
	//端の要素のとき true
	isLeaf = false;
	
	//列のとき true
	isArray = false;
	
	//get可能のとき true
	isReadable = false;
	
	//set可能のとき true
	isWriteable = false;
	
	//getAllValue/setAllValueの対象
	isSerializable = false;
	
	//必須項目のとき true
	isMandatory = false;
	
	//値のデータ型
	valueType = 0;
	
	//空値を許すとき true
	canBeBlank = false;
	
	//メンバ定義テーブル
	memberTable = null;
	
	//putParam/getParam name
	keyWord = null;
	
	//デフォルトデータ
	defaultData = null;
   }
   
   private static void init() {
    if ( g_cbtProto == null || g_launchProto == null || g_lessonProto == null 
   				 ||g_evaluationProto == null || g_g_cbtProto == null) {
		CMIElementProto proto = new CMIElementProto();
		g_cbtProto = proto.createGCbtProto();
		g_launchProto = proto.createGLaunchProto();
		g_lessonProto = proto.createGLessonProto();
		g_evaluationProto = proto.createGEvaluationProto();
		g_g_cbtProto = proto.createGGCbtProto();
	}
   }
   
   /**
    * 名前の取得<br>
    * @return 名前
    */
	  public String getName() {
		   return name;
	  }
	  
   /**
    * グローバル判定<br>
    * @return グローバル状態
    */
   public boolean getIsGlobal() {
    	return isGlobal;
   }
   
   /**
    * セッション初期化タイプ判定<br>
    * @return グローバル状態
    */
   public boolean getIsSession() {
    	return isSession;
   }
   
   /**
    * 終端タイプ判定<br>
    * @return 終端タイプ
    */
   public boolean getIsLeaf() {
    	return isLeaf;
   }
   
   /**
    * 配列判定<br>
    * @return 配列判定
    */
   public boolean getIsArray() {
    	return isArray;
   }
   
   /**
    * get可能判定<br>
    * @return get可能j状態
    */
   public boolean getIsReadable() {
    	return isReadable;
   }
   
   /**
    * set可能判定<br>
    * @return get可能j状態
    */
   public boolean getIsWritable() {
    	return isWriteable;
   }
   
   /**
    * 必須項目判定<br>
    * @return 必須項目の状態
    */
   public boolean getIsMandatory() {
    	return isMandatory;
   }
   
   /**
    * シリアライズ判定<br>
    * @return シリアライズの状態
    */
   public boolean getIsSerializable() {
    	return isSerializable;
   }
   
   /**
    * 値のデータ型を取得する処理<br>
    * @return 値のデータ型
    */
   public int getValueType() {
    	return valueType;
   }
   
   /**
    * 空値を許すを取得する<br>
    * @return 空値を許すの状態
    */
	public boolean getCanBeBlank() {
	   return canBeBlank;
	}
   
   /**
    * メンバ定義テーブルを取得する処理<br>
    * @return メンバ定義テーブル
    */
   public Vector getMemberTable() {
    	return memberTable;
   }
   
   /**
    * キーワードを取得する処理<br>
    * @return キーワード
    */
   public String getKeyWord() {
    	return keyWord;
   }
   
   /**
    * デフォルトデータを取得する処理<br>
    * @return デフォルトデータ
    */
   public String getDefaultData() {
    	return defaultData;
   }

	/**
	 * SCORM1.3モデルの名前を設定する<br>
     * @return SCORM1.3モデル名
	 */
	public String getScorm13Name() {
		return scormName;
	}
   
   /**
    * デフォルトデータを取得する処理<br>
    * @return デフォルトデータ
    */
   public IInitializer getInitializer() {
    	return initializer;
   }
   
   /**
    * 初期化直前用のオブジェクトを取得する処理<br>
    * @return 初期化直前用のオブジェクト
    */
   public IBeforeInitializer getBeforeInitializer() {
    	return beforeInitializer;
   }
   
   /**
    * PutParam用情報のオブジェクトを取得する処理<br>
    * @return 初期化直前用のオブジェクト
    */
   public IMaintenancePutParam getMaintenancePutParam() {
    	return maintenancePutParam;
   }
   
   /**
    * GetParam用情報のオブジェクトを取得する処理<br>
    * @return GetParam用情報用のオブジェクト
    */
   public IMaintenanceGetParam getMaintenanceGetParam() {
    	return maintenanceGetParam;
   }
   
   /**
    * @return IMaintenanceSetValue
    */
   public IMaintenanceSetValue getMaintenanceSetValue() {
    return maintenanceSetValue;
   }
   
   /**
    * SetValue用情報のオブジェクトを取得する処理<br>
    * @return SetValue用情報用のオブジェクト
    */
   public IMaintenanceGetValue getMaintenanceGetValue() {
    	return maintenanceGetValue;
   }
   
   /**
    * GetValue用情報のオブジェクトを取得する処理<br>
    * @return GetValue用情報用のオブジェクト
    */
   public IMaintenanceGetPutParam getMaintenanceGetPutParam() {
    	return maintenanceGetPutParam;
   }
   /**
    * 名前を設定する<br>
    * @param name 名前
    */
   public void setName(String name) {
		  this.name = name;
   }   
   /**
    * グローバル判定を設定する<br>
    * @param global グローバル状態
    */
	 public void setIsGlobal(boolean global) {
    	this.isGlobal = global;
	 }
   
	 /**
	  * セッション初期化タイプを設定する<br>
	  * @param session セッション状態
	  */
	 public void setIsSession(boolean session) {
    	this.isSession = session;
	 }
   
	 /**
	  * 終端タイプ判定を設定する<br>
	  * @param leaf 終端タイプ判定
	  */
	 public void setIsLeaf(boolean leaf) {
    	this.isLeaf = leaf;
	 }
   
	/**
	 * 配列タイプ判定を設定する。<br>
	 * @param array boolean データモデル種別が配列ならtrue、配列以外ならfalse 
	 */
	public void setIsArray(boolean array) {
		this.isArray = array;
	}
	 /**
	  * get可能状態を設定する<br>
	  * @param readable get可能状態
	  */
	 public void setIsReadable(boolean readable) {
    	this.isReadable = readable;
	 }
   
	/**
	 * set可能状態を設定する<br>
	 * @param writeable set可能状態
	 */
	 public void setIsWritable(boolean writeable) {
    	this.isWriteable = writeable;
	 }
   
	/**
	 * 必須項目判定を設定する<br>
	 * @param mandatory 必須項目判定
	 */
	 public void setIsMandatory(boolean mandatory) {
		this.isMandatory = mandatory;
	 }

	/**
	 * serializableを設定する<br>
	 * @param serializable 
	 */
	public void setIsSerializable(boolean serializable) {
		this.isSerializable = serializable;
	}
	/**
	 * 値のデータ型を設定する<br>
	 * @param type 値のデータ型
	 */
	 public void setValueType(int type) {
    	this.valueType = type;
	 }
   
	/**
	 * 空値を許すを設定する<br>
	 * @param blank 空値を許す
	 */
	public void setCanBeBlank(boolean blank) {
		this.canBeBlank = blank;
	}
	 /**
	  * メンバ定義テーブルを設定する<br>
	  * @param memberTbl メンバ定義テーブル
	  */
	 public void setMemberTable(Vector memberTbl) {
    	this.memberTable = memberTbl;
	 }
	 
	 /**
	  * キーワードを設定する<br>
	  * @param keyWord キーワード
	  */
	 public void setKeyWord(String keyWord) {
    	this.keyWord = keyWord;
	 }

	 /**
	  * デフォルトデータを設定する<br>
	  * @param strDefaultData デフォルトデータ
	  */
	 public void setDefaultData(String strDefaultData) {
    	this.defaultData = strDefaultData;
	 }

	/**
	 * SCORM1.3モデルの名前を設定する。<br>
	 * @param name String データモデル名
	 */
	public void setScorm13Name(String name) {
	   this.scormName = name;
	}
   
	/**
	 * 初期化用のオブジェクトを設定する。<br>
	 * @param init IInitializer 初期化用のオブジェクト
	 */
	public void setInitializer(IInitializer init) {
    	this.initializer = init;
	}
   
	/**
	 * 初期化直前用のオブジェクトを設定する。<br>
	 * @param before IBeforeInitializer 初期化直前用のオブジェクト 
	 */
	public void setBeforeInitializer(IBeforeInitializer before) {
		this.beforeInitializer = before;
	}
   
	/**
	 * PutParamコマンド受信時に動作する処理インタフェースを設定する。<br>
	 * @param PutParam IMaintenanceGetParam PutParam用インタフェース
	 */
	 public void setMaintenancePutParam(IMaintenancePutParam PutParam) {
		this.maintenancePutParam = PutParam;
	 }
		 
	 /**
	  * GetParamコマンド受信時に動作する処理インタフェースを設定する。<br>
	  * @param GetParam IMaintenanceGetParam GetParam用インタフェース
	  */
	 public void setMaintenanceGetParam(IMaintenanceGetParam GetParam) {
    	this.maintenanceGetParam = GetParam;
	 }
   
	 /**
	  * setValueメソッド呼び出し時に動作する処理インタフェースを設定する。<br>
	  * @param setValue IMaintenanceSetValue setValue用インタフェース
	  */
	 public void setMaintenanceSetValue(IMaintenanceSetValue setValue) {
    	this.maintenanceSetValue = setValue;
	 }
   
	 /**
	  * getValueメソッド呼び出し時に動作する処理インタフェースを設定する。<br>
	  * @param getValue IMaintenanceGetValue getValue用インタフェース
	  */
	 public void setMaintenanceGetValue(IMaintenanceGetValue getValue) {
    	this.maintenanceGetValue = getValue;
	 }
   
	 /**
	  * PutParamコマンド形式のデータを取得する処理インタフェースを設定する。<br>
	  * @param GetPutParam IMaintenanceGetPutParam PutParam形式データ取得インタフェース
	  */
	 public void setMaintenanceGetPutParam(IMaintenanceGetPutParam GetPutParam) {
    	this.maintenanceGetPutParam = GetPutParam;
	 }
	/**
	 * cmi.objectives_statusデータを生成する。<br>
	 * @return cmi.objectives_statusデータ
	 */
	 private Vector createPdObjectivesStatus(){
	 	
		Vector vtrTable = new Vector();

		//course_idデータを生成する
		CMIElementProto courseID = new CMIElementProto(  );
		courseID.setName("course_id");
		courseID.setIsSession( true );
		courseID.setIsReadable( true );
		courseID.setValueType( CMIIdentifier );

		vtrTable.add(courseID);
		
		//student_idデータを生成する
		CMIElementProto studentID = new CMIElementProto(  );
		studentID.setName("student_id");
		studentID.setIsSession( true );
		studentID.setIsReadable( true );
		studentID.setValueType( CMIIdentifier );
		vtrTable.add(studentID);
		
		// lesson_idデータを生成する
		CMIElementProto lessonID = new CMIElementProto(  );
		lessonID.setName("lesson_id");
		lessonID.setIsSession( true );
		lessonID.setIsReadable( true );
		lessonID.setValueType( CMIString256 );

		vtrTable.add(lessonID);
		
		//dateデータを生成する
		CMIElementProto date = new CMIElementProto(  );
		date.setName("date");
		date.setIsSession( true );
		date.setIsReadable( true );
		date.setValueType( CMIDate );
		vtrTable.add(date);
		
		//timeデータを生成する
		CMIElementProto time = new CMIElementProto(  );
		time.setName("time");
		time.setIsSession( true );
		time.setIsReadable( true );
		time.setValueType( CMITime );
		vtrTable.add(time);
		
		//idデータを生成する
		CMIElementProto id = new CMIElementProto(  );
		id.setName("id");
		id.setIsSession( true );
		id.setIsReadable( true );
		id.setValueType( CMIIdentifier );
		vtrTable.add(id);
		
		//scoresデータを生成する
		CMIElementProto scores = new CMIElementProto(  );
		scores.setName("scores");
		scores.setIsSession( true );
		scores.setIsReadable( true );
		scores.setValueType( CMIInteger );
		vtrTable.add(scores);
			  
		//statusデータを生成する
		CMIElementProto status = new CMIElementProto(  );
		status.setName("status");
		status.setIsSession( true );
		status.setIsReadable( true );
		status.setValueType( CMIVocabulary );
		status.setCanBeBlank( false );

		vtrTable.add(status);
					
		//mastery_timeデータを生成する
		CMIElementProto mastery_time = new CMIElementProto(  );
		mastery_time.setName("mastery_time");
		mastery_time.setIsSession( true );
		mastery_time.setIsReadable( true );
		mastery_time.setValueType( CMITimespan );
		vtrTable.add(mastery_time);
		
		CMIElementProto objectivesStatus = new CMIElementProto(  );
		
		objectivesStatus.setName("n");
		objectivesStatus.setValueType( CMIIdentifier );
		objectivesStatus.setMemberTable( vtrTable );
		Vector vtrObjectivesStatus = new Vector();
		vtrObjectivesStatus.add(objectivesStatus);
		return 	vtrObjectivesStatus;
	 }
	 
	/**
	 * cmi.pathsデータを生成する<br>
	 * @return cmi.pathsデータ
	 */
	private Vector createPdPaths(){
		
		Vector vtrTable = new Vector();
		
		//course_idデータを生成する
		CMIElementProto courseID = new CMIElementProto(  );
		courseID.setName("course_id");
		courseID.setIsSession( true );
		courseID.setIsLeaf( true );
		courseID.setIsReadable( true );
		courseID.setValueType( CMIIdentifier );
		vtrTable.add(courseID);
		
		//student_idデータを生成する
		CMIElementProto studentID = new CMIElementProto(  );
		studentID.setName("student_id");
		studentID.setIsSession( true );
		studentID.setIsLeaf( true );
		studentID.setIsReadable( true );
		studentID.setValueType( CMIIdentifier );

		vtrTable.add(studentID);
		
		//lesson_idデータを生成する
		CMIElementProto lessonID = new CMIElementProto(  );
		lessonID.setName("lesson_id");
		lessonID.setIsSession( true );
		lessonID.setIsLeaf( true );
		lessonID.setIsReadable( true );
		lessonID.setValueType( CMIString256 );
		vtrTable.add(lessonID);
		
		//dateデータを生成する
		 CMIElementProto date = new CMIElementProto(  );
		 date.setName("date");
		 date.setIsSession( true );
		 date.setIsLeaf( true );
		 date.setIsReadable( true );
		 date.setValueType( CMIDate );
		vtrTable.add(date);
		 
		//location_idデータを生成する
		CMIElementProto locationID = new CMIElementProto(  );
		locationID.setName("location_id");
		locationID.setIsSession( true );
		locationID.setIsLeaf( true );
		locationID.setIsReadable( true );
		locationID.setValueType( CMIString256 );
		vtrTable.add(locationID);
		
		//timeデータを生成する
		CMIElementProto time = new CMIElementProto(  );
		time.setName("time");
		time.setIsSession( true );
		time.setIsLeaf( true );
		time.setIsReadable( true );
		time.setValueType( CMITime );
		vtrTable.add(time);
		
		//statusデータを生成する
		CMIElementProto status = new CMIElementProto(  );
		status.setName("status");
		status.setIsSession( true );
		status.setIsLeaf( true );
		status.setIsReadable( true );
		status.setValueType( CMIVocabulary );
		vtrTable.add(status);
		
		//whyleftデータを生成する
		CMIElementProto whyLeft = new CMIElementProto(  );
		whyLeft.setName("why_left");
		whyLeft.setIsSession( true );
		whyLeft.setIsLeaf( true );
		whyLeft.setIsReadable( true );
		whyLeft.setValueType( CMIVocabulary );
		vtrTable.add(whyLeft);
		
		//time_in_elementデータを生成する
		CMIElementProto timeInElement = new CMIElementProto(  );
		timeInElement.setName("time_in_element");
		timeInElement.setIsSession( true );
		timeInElement.setIsLeaf( true );
		timeInElement.setIsReadable( true );
		timeInElement.setValueType( CMITimespan );
		vtrTable.add(timeInElement);
		
		CMIElementProto pdPaths = new CMIElementProto(  );
		pdPaths.setName("n");
		pdPaths.setIsSession( true );
		pdPaths.setIsLeaf( true );
		pdPaths.setValueType( CMIIdentifier );
		pdPaths.setMemberTable( vtrTable );
		
		Vector vtrPdPaths = new Vector();
		vtrPdPaths.add(pdPaths);
		return vtrPdPaths;
	}
	/**
	 * cmi.interactions.correct_responsesデータを生成する<br>
	 * @return cmi.interactions.correct_responsesデータ
	 */
	private Vector createInteractionCorrectRes(){
		
		Vector vtrTable = new Vector();
		
		//cmi.interactions.correct_responses.nデータを生成する
		CMIElementProto correctResN = new CMIElementProto( );
		correctResN.setName("pattern");
		correctResN.setIsSession( true );
		correctResN.setIsLeaf( true );
		correctResN.setIsReadable( true );
		correctResN.setValueType( CMIFeedback );
		vtrTable.add(correctResN);
		
		//cmi.interactions.correct_responsesデータを生成する
		CMIElementProto correctRes = new CMIElementProto(  );
		correctRes.setName("n");
		correctRes.setIsSession( true );
		correctRes.setValueType( CMIIdentifier );
		correctRes.setMemberTable( vtrTable );
		
		Vector vtrCorrectRes = new Vector();
		vtrCorrectRes.add( correctRes );
		return vtrCorrectRes;
		
	}
	
	/**
	 * cmi.interactions.objectives データを生成する<br>
	 * @return cmi.interactions.objectivesデータ
	 */
	private Vector createPdIntObjectives(){
		
		Vector vtrTable = new Vector();
		
		//cmi.interactions.objectives.nデータを生成する
		CMIElementProto interactionObjectivesN = new CMIElementProto(  );
		interactionObjectivesN.setName("id");
		interactionObjectivesN.setIsSession( true );
		interactionObjectivesN.setIsLeaf( true );
		interactionObjectivesN.setIsReadable( true );
		interactionObjectivesN.setValueType( CMIIdentifier );
		vtrTable.add(interactionObjectivesN);
		
		//cmi.interactions.objectivesデータを生成する
		CMIElementProto interactionObjectives = new CMIElementProto(  );
		interactionObjectives.setName("n");
		interactionObjectives.setIsSession( true );
		interactionObjectives.setValueType( CMIIdentifier );
		interactionObjectives.setMemberTable( vtrTable );
		
		Vector vtrInteraction = new Vector();
		vtrInteraction.add(interactionObjectives);
		return vtrInteraction;
		
	}
	
	/**
	 * cmi.interactions データを生成する<br>
	 * @return cmi.interactionsデータ
	 */
	private Vector createPdNInteractions(){
	
		Vector vtrTable = new Vector();
		
		//course_idデータを生成する
		CMIElementProto courseID = new CMIElementProto(  );
		courseID.setName("course_id");
		courseID.setIsSession( true );
		courseID.setIsLeaf( true );
		courseID.setIsReadable( true );
		courseID.setValueType( CMIIdentifier );
		vtrTable.add(courseID);
		
		//student_idデータを生成する
		CMIElementProto studentID = new CMIElementProto(  );
		studentID.setName("student_id");
		studentID.setIsSession( true );
		studentID.setIsLeaf( true );
		studentID.setIsReadable( true );
		studentID.setValueType( CMIIdentifier );
		vtrTable.add(studentID);
		
		//lesson_idデータを生成する
		CMIElementProto lessonID = new CMIElementProto(  );
		lessonID.setName("lesson_id");
		lessonID.setIsSession( true );
		lessonID.setIsLeaf( true );
		lessonID.setIsReadable( true );
		lessonID.setValueType( CMIString256 );
		vtrTable.add(lessonID);
		
		//date(timestamp)データを生成する
		CMIElementProto date = new CMIElementProto(  );
		date.setName("date");
		date.setIsSession( true );
		date.setIsLeaf( true );
		date.setIsReadable( true );
		date.setValueType( CMITime );
		vtrTable.add(date);
		
		//idデータを生成する
		CMIElementProto id = new CMIElementProto(  );
		id.setName("id");
		id.setIsSession( true );
		id.setIsLeaf( true );
		id.setIsReadable( true );
		id.setValueType( CMIIdentifier );
		vtrTable.add(id);
		
		//objectivesデータを生成する
		CMIElementProto objectives = new CMIElementProto(  );
		objectives.setName("objectives");
		objectives.setIsSession( true );
		objectives.setIsArray( true );
		objectives.setValueType( CMINoType );
		
		//cmi.interactions.objectivesデータを生成する
		Vector vtrPdIntObjectives = createPdIntObjectives();
		
		//メンバーテーブルをセットする
		objectives.setMemberTable( vtrPdIntObjectives );

		vtrTable.add(objectives);
		
		//timeデータを生成する
		CMIElementProto time = new CMIElementProto(  );
		time.setName("time");
		time.setIsSession( true );
		time.setIsLeaf( true );
		time.setIsReadable(true);
		time.setValueType( CMITime );
		
		vtrTable.add(time);
		
		//typeデータを生成する
		CMIElementProto type = new CMIElementProto(  );
		type.setName("type");
		type.setIsSession( true );
		type.setIsLeaf( true );
		type.setIsReadable( true );
		type.setValueType( CMIVocabulary );
		vtrTable.add(type);
		
		//correct_responsesデータを生成する
		CMIElementProto correct_responses = new CMIElementProto(  );
		correct_responses.setName("correct_responses");
		correct_responses.setIsSession( true );
		correct_responses.setIsArray( true );
		correct_responses.setValueType( CMINoType );
		
		//pd_correct_responsesデータを生成する
		Vector vtrPdCorrectRes = createInteractionCorrectRes();
		
		//メンバーテーブルをセットする
		correct_responses.setMemberTable( vtrPdCorrectRes );
		
		vtrTable.add(correct_responses);
		
		//weightingデータを生成する
		CMIElementProto weighting = new CMIElementProto(  );
		weighting.setName("weighting");
		weighting.setIsSession( true );
		weighting.setIsLeaf( true );
		weighting.setIsReadable( true );
		weighting.setValueType( CMIDecimal );
		vtrTable.add(weighting);
		
		//student_response(learner_response)データを生成する
		CMIElementProto studentResponse = new CMIElementProto(  );
		studentResponse.setName("student_response");
		studentResponse.setIsSession( true );
		studentResponse.setIsLeaf( true );
		studentResponse.setIsReadable( true );
		studentResponse.setValueType( CMIFeedback );
		vtrTable.add(studentResponse);		
		
		//resultデータを生成する
		CMIElementProto result = new CMIElementProto(  );
		result.setName("result");
		result.setIsSession( true );
		result.setIsLeaf( true );
		result.setIsReadable( true );
		result.setValueType( CMIVocabulary );
		vtrTable.add(result);
		
		//latencyデータを生成する
		CMIElementProto latency = new CMIElementProto(  );
		latency.setName("latency");
		latency.setIsSession( true );
		latency.setIsLeaf( true );
		latency.setIsReadable( true );
		latency.setValueType( CMITimespan );
		vtrTable.add(latency);

		//descriptionデータを生成する
		CMIElementProto description = new CMIElementProto(  );
		description.setName("description");
		description.setIsSession( true );
		description.setIsLeaf( true );
		description.setIsReadable( true );
		description.setValueType( CMIString256 );
		vtrTable.add(description);
		
		return vtrTable;
	}	
		
	/**
	 * cmi.interactions データを生成する<br>
	 * @return cmi.interactionsデータ
	 */
	private Vector createPdInteractions(){
		//cmi.interactionsデータを生成する
		CMIElementProto pd_interactions = new CMIElementProto();
		pd_interactions.setName("n");
		pd_interactions.setIsSession(true);
		pd_interactions.setValueType( CMIIdentifier );
		
		Vector vtrPdInteraction = createPdNInteractions();
		pd_interactions.setMemberTable( vtrPdInteraction );
	
		Vector vtrRet = new Vector();
		vtrRet.add(pd_interactions);
		return vtrRet;
		
	}
		
	/**
	 * cmi.student_preference.windows データを生成する<br>
	 * @return cmi.student_preference.windowsデータ
	 */
	private Vector createPdWindows(){
		//course_idデータを生成する
		CMIElementProto pd_windows = new CMIElementProto( );
		pd_windows.setName("n");
		pd_windows.setIsLeaf( true );
		pd_windows.setIsReadable( true );
		pd_windows.setIsWritable( true );
		pd_windows.setIsSerializable( true );
		pd_windows.setValueType( CMIString256 );
		
		Vector vtrPdWindows = new Vector();
		vtrPdWindows.add(pd_windows);
		return vtrPdWindows;
	}
	
		
	/**
	 * cmi.student_preference データを生成する<br>
	 * @return cmi.student_preferenceデータ
	 */
	private Vector createPdStPreference() {
		
		Vector vtrTable = new Vector();
		if ( IS_GLOBAL_MEM ) {
			
			//audioデータを生成する
			CMIElementProto audio = new CMIElementProto( );
			audio.setName("audio");
			audio.setIsGlobal(true);
			audio.setIsLeaf( true );
			audio.setIsReadable( true );
			audio.setIsWritable( true );
			audio.setIsSerializable( true );
			audio.setValueType( CMISInteger );
			vtrTable.add(audio);
			
			//languageデータを生成する
			CMIElementProto language = new CMIElementProto( );
			language.setName("language");
			language.setIsGlobal(true);
			language.setIsLeaf( true );
			language.setIsReadable( true );
			language.setIsWritable( true );
			language.setIsSerializable( true );
			language.setValueType( CMIString256 );			
			vtrTable.add(language);

			//lesson_typeデータを生成する
			CMIElementProto lesson_type = new CMIElementProto( );
			lesson_type.setName("lesson_type");
			lesson_type.setIsGlobal(true);
			lesson_type.setIsLeaf( true );
			lesson_type.setIsReadable( true );
			lesson_type.setIsWritable( true );
			lesson_type.setIsSerializable( true );
			lesson_type.setValueType( CMIString256 );			
			vtrTable.add(lesson_type);			
			
			//speedデータを生成する
			CMIElementProto speed = new CMIElementProto( );
			speed.setName("speed");
			speed.setIsGlobal(true);
			speed.setIsLeaf( true );
			speed.setIsReadable( true );
			speed.setIsWritable( true );
			speed.setIsSerializable( true );
			speed.setValueType( CMISInteger );			
			vtrTable.add(speed);
			
			//textデータを生成する
			CMIElementProto text = new CMIElementProto( );
			text.setName("text");
			text.setIsGlobal(true);
			text.setIsLeaf( true );
			text.setIsReadable( true );
			text.setIsWritable( true );
			text.setIsSerializable( true );
			text.setValueType( CMISInteger );			
			vtrTable.add(text);

			//text_colorデータを生成する
			CMIElementProto text_color = new CMIElementProto( );
			text_color.setName("text_color");
			text_color.setIsGlobal(true);
			text_color.setIsLeaf( true );
			text_color.setIsReadable( true );
			text_color.setIsWritable( true );
			text_color.setIsSerializable( true );
			text_color.setValueType( CMIString256 );			
			vtrTable.add(text_color);
			
			//text_locationデータを生成する
			CMIElementProto text_location = new CMIElementProto( );
			text_location.setName("text_location");
			text_location.setIsGlobal(true);
			text_location.setIsLeaf( true );
			text_location.setIsReadable( true );
			text_location.setIsWritable( true );
			text_location.setIsSerializable( true );
			text_location.setValueType( CMIString256 );			
			vtrTable.add(text_location);
			
			//text_sizeデータを生成する
			CMIElementProto text_size = new CMIElementProto( );
			text_size.setName("text_size");
			text_size.setIsGlobal(true);
			text_size.setIsLeaf( true );
			text_size.setIsReadable( true );
			text_size.setIsWritable( true );
			text_size.setIsSerializable( true );
			text_size.setValueType( CMIString256 );			
			vtrTable.add(text_size);
			
			//videoデータを生成する
			CMIElementProto video = new CMIElementProto( );
			video.setName("video");
			video.setIsGlobal(true);
			video.setIsLeaf( true );
			video.setIsReadable( true );
			video.setIsWritable( true );
			video.setIsSerializable( true );
			video.setValueType( CMIString256 );			
			vtrTable.add(video);
				
			//windowsデータを生成する
			CMIElementProto windows = new CMIElementProto( );
			windows.setName("windows");
			windows.setIsGlobal(true);
			windows.setIsArray( true );
			windows.setValueType( CMIString256 );
			Vector vtrPdWindows = createPdWindows();
			windows.setMemberTable(vtrPdWindows);
			windows.setKeyWord("Window");
			vtrTable.add(windows);
			
		} else {
			//audioデータを生成する
			CMIElementProto audio = new CMIElementProto( );
			audio.setName("audio");
			audio.setIsLeaf( true );
			audio.setIsReadable( true );
			audio.setIsWritable( true );
			audio.setIsSerializable( true );
			audio.setValueType( CMISInteger );
			vtrTable.add(audio);
			
			//languageデータを生成する
			CMIElementProto language = new CMIElementProto( );
			language.setName("language");
			language.setIsLeaf( true );
			language.setIsReadable( true );
			language.setIsWritable( true );
			language.setIsSerializable( true );
			language.setValueType( CMIString256 );			
			vtrTable.add(language);

			//lesson_typeデータを生成する
			CMIElementProto lesson_type = new CMIElementProto( );
			lesson_type.setName("lesson_type");
			lesson_type.setIsLeaf( true );
			lesson_type.setIsReadable( true );
			lesson_type.setIsWritable( true );
			lesson_type.setIsSerializable( true );
			lesson_type.setValueType( CMIString256 );			
			vtrTable.add(lesson_type);			
			
			//speedデータを生成する
			CMIElementProto speed = new CMIElementProto( );
			speed.setName("speed");
			speed.setIsLeaf( true );
			speed.setIsReadable( true );
			speed.setIsWritable( true );
			speed.setIsSerializable( true );
			speed.setValueType( CMISInteger );			
			vtrTable.add(speed);
			
			//textデータを生成する
			CMIElementProto text = new CMIElementProto( );
			text.setName("text");
			text.setIsLeaf( true );
			text.setIsReadable( true );
			text.setIsWritable( true );
			text.setIsSerializable( true );
			text.setValueType( CMISInteger );			
			vtrTable.add(text);

			//text_colorデータを生成する
			CMIElementProto text_color = new CMIElementProto( );
			text_color.setName("text_color");
			text_color.setIsLeaf( true );
			text_color.setIsReadable( true );
			text_color.setIsWritable( true );
			text_color.setIsSerializable( true );
			text_color.setValueType( CMIString256 );			
			vtrTable.add(text_color);
			
			//text_locationデータを生成する
			CMIElementProto text_location = new CMIElementProto( );
			text_location.setName("text_location");
			text_location.setIsLeaf( true );
			text_location.setIsReadable( true );
			text_location.setIsWritable( true );
			text_location.setIsSerializable( true );
			text_location.setValueType( CMIString256 );			
			vtrTable.add(text_location);
			
			//text_sizeデータを生成する
			CMIElementProto text_size = new CMIElementProto( );
			text_size.setName("text_size");
			text_size.setIsLeaf( true );
			text_size.setIsReadable( true );
			text_size.setIsWritable( true );
			text_size.setIsSerializable( true );
			text_size.setValueType( CMIString256 );			
			vtrTable.add(text_size);
			
			//videoデータを生成する
			CMIElementProto video = new CMIElementProto( );
			video.setName("video");
			video.setIsLeaf( true );
			video.setIsReadable( true );
			video.setIsWritable( true );
			video.setIsSerializable( true );
			video.setValueType( CMIString256 );			
			vtrTable.add(video);
				
			//windowsデータを生成する
			CMIElementProto windows = new CMIElementProto( );
			windows.setName("windows");
			windows.setIsArray( true );
			windows.setValueType( CMIString256 );
			Vector vtrPdWindows = createPdWindows();
			windows.setMemberTable(vtrPdWindows);
			windows.setKeyWord("Window");
			vtrTable.add(windows);	
		}
		return vtrTable;
	}
	
	/**
	 * cmi.student_demographics データを生成する<br>
	 * @return cmi.student_demographicsデータ
	 */
	private Vector createPdStDemographics() {
		Vector vtrTable = new Vector();
		if ( IS_GLOBAL_MEM ) {
			
			//audioデータを生成する
			CMIElementProto city = new CMIElementProto( );
			city.setName("city");
			city.setIsGlobal(true);
			city.setIsLeaf( true );
			city.setIsReadable( true );
			city.setValueType( CMIString256 );
			vtrTable.add(city);
			
			//languageデータを生成する
			CMIElementProto cmiclass = new CMIElementProto( );
			cmiclass.setName("class");
			cmiclass.setIsGlobal(true);
			cmiclass.setIsLeaf( true );
			cmiclass.setIsReadable( true );
			cmiclass.setValueType( CMIString256 );			
			vtrTable.add(cmiclass);

			//companyデータを生成する
			CMIElementProto company = new CMIElementProto( );
			company.setName("company");
			company.setIsGlobal(true);
			company.setIsLeaf( true );
			company.setIsReadable( true );
			company.setValueType( CMIString256 );			
			vtrTable.add(company);	
			
			//countryデータを生成する
			CMIElementProto country = new CMIElementProto( );
			country.setName("country");
			country.setIsGlobal(true);
			country.setIsLeaf( true );
			country.setIsReadable( true );
			country.setValueType( CMIString256 );			
			vtrTable.add(country);
			
			//experienceデータを生成する
			CMIElementProto experience = new CMIElementProto( );
			experience.setName("experience");
			experience.setIsGlobal(true);
			experience.setIsLeaf( true );
			experience.setIsReadable( true );
			experience.setValueType( CMIString256 );
			vtrTable.add(experience);
			
			//familiar_nameデータを生成する
			CMIElementProto familiar_name = new CMIElementProto( );
			familiar_name.setName("familiar_name");
			familiar_name.setIsGlobal(true);
			familiar_name.setIsLeaf( true );
			familiar_name.setIsReadable( true );
			familiar_name.setValueType( CMIString256 );			
			vtrTable.add(familiar_name);
			
			//instructor_nameデータを生成する
			CMIElementProto instructor_name = new CMIElementProto( );
			instructor_name.setName("instructor_name");
			instructor_name.setIsGlobal(true);
			instructor_name.setIsLeaf( true );
			instructor_name.setIsReadable( true );
			instructor_name.setValueType( CMIString256 );			
			vtrTable.add(instructor_name);
			
			//titleデータを生成する
			CMIElementProto title = new CMIElementProto( );
			title.setName("title");
			title.setIsGlobal(true);
			title.setIsLeaf( true );
			title.setIsReadable( true );
			title.setValueType( CMIString256 );			
			vtrTable.add(title);
			
			//native_languageデータを生成する
			CMIElementProto native_language = new CMIElementProto( );
			native_language.setName("native_language");
			native_language.setIsGlobal(true);
			native_language.setIsLeaf( true );
			native_language.setIsReadable( true );
			native_language.setValueType( CMIString256 );			
			vtrTable.add(native_language);
			
			//stateデータを生成する
			CMIElementProto state = new CMIElementProto( );
			state.setName("state");
			state.setIsGlobal(true);
			state.setIsLeaf( true );
			state.setIsReadable( true );
			state.setValueType( CMIString256 );			
			vtrTable.add(state);
			
			//street_addressデータを生成する
			CMIElementProto street_address = new CMIElementProto( );
			street_address.setName("street_address");
			street_address.setIsGlobal(true);
			street_address.setIsLeaf( true );
			street_address.setIsReadable( true );
			street_address.setValueType( CMIString256 );			
			vtrTable.add(street_address);
			
			//telephoneデータを生成する
			CMIElementProto telephone = new CMIElementProto( );
			telephone.setName("telephone");
			telephone.setIsGlobal(true);
			telephone.setIsLeaf( true );
			telephone.setIsReadable( true );
			telephone.setValueType( CMIString256 );			
			vtrTable.add(telephone);
			
			//years_experienceデータを生成する
			CMIElementProto years_experience = new CMIElementProto( );
			years_experience.setName("years_experience");
			years_experience.setIsGlobal(true);
			years_experience.setIsLeaf( true );
			years_experience.setIsReadable( true );
			years_experience.setValueType( CMIString256 );			
			vtrTable.add(years_experience);	
			
		} else {	
			
			//audioデータを生成する
			CMIElementProto city = new CMIElementProto( );
			city.setName("city");
			city.setIsLeaf( true );
			city.setIsReadable( true );
			city.setIsWritable( true );
			city.setValueType( CMIString256 );
			vtrTable.add(city);
			
			//languageデータを生成する
			CMIElementProto cmiclass = new CMIElementProto( );
			cmiclass.setName("class");
			cmiclass.setIsLeaf( true );
			cmiclass.setIsReadable( true );
			cmiclass.setIsWritable( true );
			cmiclass.setValueType( CMIString256 );			
			vtrTable.add(cmiclass);

			//companyデータを生成する
			CMIElementProto company = new CMIElementProto( );
			company.setName("company");
			company.setIsLeaf( true );
			company.setIsReadable( true );
			company.setIsWritable( true );
			company.setValueType( CMIString256 );			
			vtrTable.add(company);	
			
			//countryデータを生成する
			CMIElementProto country = new CMIElementProto( );
			country.setName("country");
			country.setIsLeaf( true );
			country.setIsReadable( true );
			country.setIsWritable( true );
			country.setValueType( CMIString256 );			
			vtrTable.add(country);
			
			//experienceデータを生成する
			CMIElementProto experience = new CMIElementProto( );
			experience.setName("experience");
			experience.setIsLeaf( true );
			experience.setIsReadable( true );
			experience.setIsWritable( true );
			experience.setValueType( CMIString256 );			
			vtrTable.add(experience);
			
			//familiar_nameデータを生成する
			CMIElementProto familiar_name = new CMIElementProto( );
			familiar_name.setName("familiar_name");
			familiar_name.setIsLeaf( true );
			familiar_name.setIsReadable( true );
			familiar_name.setIsWritable( true );
			familiar_name.setValueType( CMIString256 );			
			vtrTable.add(familiar_name);
			
			//instructor_nameデータを生成する
			CMIElementProto instructor_name = new CMIElementProto( );
			instructor_name.setName("instructor_name");
			instructor_name.setIsLeaf( true );
			instructor_name.setIsReadable( true );
			instructor_name.setIsWritable( true );
			instructor_name.setValueType( CMIString256 );			
			vtrTable.add(instructor_name);
			
			//titleデータを生成する
			CMIElementProto title = new CMIElementProto( );
			title.setName("title");
			title.setIsLeaf( true );
			title.setIsReadable( true );
			title.setIsWritable( true );
			title.setValueType( CMIString256 );			
			vtrTable.add(title);
			
			//native_languageデータを生成する
			CMIElementProto native_language = new CMIElementProto( );
			native_language.setName("native_language");
			native_language.setIsLeaf( true );
			native_language.setIsReadable( true );
			native_language.setIsWritable( true );
			native_language.setValueType( CMIString256 );			
			vtrTable.add(native_language);
			
			//stateデータを生成する
			CMIElementProto state = new CMIElementProto( );
			state.setName("state");
			state.setIsLeaf( true );
			state.setIsReadable( true );
			state.setIsWritable( true );
			state.setValueType( CMIString256 );			
			vtrTable.add(state);
			
			//street_addressデータを生成する
			CMIElementProto street_address = new CMIElementProto( );
			street_address.setName("street_address");
			street_address.setIsLeaf( true );
			street_address.setIsReadable( true );
			street_address.setIsWritable( true );
			street_address.setValueType( CMIString256 );			
			vtrTable.add(street_address);
			
			//telephoneデータを生成する
			CMIElementProto telephone = new CMIElementProto( );
			telephone.setName("telephone");
			telephone.setIsLeaf( true );
			telephone.setIsReadable( true );
			telephone.setIsWritable( true );
			telephone.setValueType( CMIString256 );			
			vtrTable.add(telephone);
			
			//years_experienceデータを生成する
			CMIElementProto years_experience = new CMIElementProto( );
			years_experience.setName("years_experience");
			years_experience.setIsLeaf( true );
			years_experience.setIsReadable( true );
			years_experience.setIsWritable( true );
			years_experience.setValueType( CMIString256 );			
			vtrTable.add(years_experience);	
		}			
		return vtrTable;
	}

	/**
	 * cmi.student_data.tries.n.score データを生成する<br>
	 * @return cmi.student_data.tries.n.scoreデータ
	 */
	private Vector createPdTriesScore() {
		Vector vtrTable = new Vector();
			
		// rawデータを生成する
		CMIElementProto raw = new CMIElementProto( );
		raw.setName("raw");
		raw.setIsSession(true);
		raw.setIsLeaf(true);
		raw.setIsReadable(true);
		raw.setValueType( CMIDecimal );
		raw.setCanBeBlank(true);
		vtrTable.add(raw);
		
		// maxデータを生成する
		CMIElementProto max = new CMIElementProto( );
		max.setName("max");
		max.setIsSession(true);
		max.setIsLeaf(true);
		max.setIsReadable(true);
		max.setValueType( CMIDecimal );
		max.setCanBeBlank(true);
		vtrTable.add(max);

		// minデータを生成する
		CMIElementProto min = new CMIElementProto( );
		min.setName("min");
		min.setIsSession(true);
		min.setIsLeaf(true);
		min.setIsReadable(true);
		min.setValueType( CMIDecimal );
		min.setCanBeBlank(true);
		vtrTable.add(min);
		
		return vtrTable;
	}
	/**
	 * cmi.student_data.tries.n データを生成する<br>
	 * @return cmi.student_data.tries.n データ
	 */
	private Vector createPdNTries() {
		Vector vtrTable = new Vector();
		
		// scoreデータを生成する
		CMIElementProto score = new CMIElementProto( );
		score.setName( "score" );
		score.setIsSession(true);
		score.setValueType( CMIInteger );
		
		
		Vector vtr = createPdTriesScore();
		score.setMemberTable( vtr );
		
		score.setKeyWord( "Try_Score" );
		vtrTable.add(score);
	
		// statusデータを生成する
		CMIElementProto status = new CMIElementProto( );
		status.setName("status");
		status.setIsSession(true);		
		status.setIsLeaf(true);
		status.setIsReadable(true);
		status.setValueType( CMIVocabulary );
		status.setKeyWord( "Try_Status" );
		vtrTable.add(status);

		// timeデータを生成する
		CMIElementProto time = new CMIElementProto( );
		time.setName("time");
		time.setIsSession(true);
		time.setIsLeaf(true);
		time.setIsReadable(true);
		time.setValueType( CMITimespan );
		time.setKeyWord( "Try_Time" );
		vtrTable.add(time);

		return vtrTable;
	}		

	/**
	 * cmi.student_data.tries データを生成する<br>
	 * @return cmi.student_data.triesデータ
	 */
	private Vector createPdTries() {
		Vector vtrTable = new Vector();
			
		// nデータを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsSession(true);
		n.setValueType( CMIInteger );
		
		Vector vtr = createPdNTries();
		n.setMemberTable( vtr );

		vtrTable.add(n);
		return vtrTable;
	}	

	/**
	 * cmi.student_data.attempt_records.n.lesson_statuses データを生成する<br>
	 * @return cmi.student_data.attempt_records.n.lesson_statusesデータ
	 */
	private Vector createPdLessonStatuses() {
		Vector vtrTable = new Vector();
			
		// nデータを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsLeaf(true);
		n.setIsReadable(true);
		n.setIsSerializable(true);
		n.setValueType( CMIDecimal );
		n.setCanBeBlank(true);
		
		vtrTable.add(n);
		return vtrTable;
	}
	
	/**
	 * cmi.student_data.attempt_records.n.lesson_scores.n データを生成する<br>
	 * @return cmi.student_data.attempt_records.n.lesson_scores.n データ
	 */
	private Vector createPdNLessonScores() {
		Vector vtrTable = new Vector();
		
		// rawデータを生成する
		CMIElementProto raw = new CMIElementProto( );
		raw.setName( "raw" );
		raw.setIsLeaf(true);
		raw.setIsReadable(true);
		raw.setIsSerializable(true);
		raw.setValueType( CMIDecimal );
		raw.setCanBeBlank(true);		
		vtrTable.add(raw);
	
		// maxデータを生成する
		CMIElementProto max = new CMIElementProto( );
		max.setName("max");
		max.setIsLeaf(true);		
		max.setIsReadable(true);
		max.setIsSerializable(true);
		max.setValueType( CMIDecimal );
		max.setCanBeBlank(true);
		vtrTable.add(max);

		// minデータを生成する
		CMIElementProto min = new CMIElementProto( );
		min.setName("min");
		min.setIsLeaf(true);		
		min.setIsReadable(true);
		min.setIsSerializable(true);
		min.setValueType( CMIDecimal );
		min.setCanBeBlank(true);
		vtrTable.add(min);

		return vtrTable;
	}	
	
	/**
	 * cmi.student_data.attempt_records.n.lesson_scores データを生成する<br>
	 * @return cmi.student_data.attempt_records.n.lesson_scores データ
	 */
	private Vector createPdLessonScores() {
		Vector vtrTable = new Vector();
			
		// nデータを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsLeaf(true);
		n.setIsSerializable(true);
		n.setValueType( CMIDecimal );
		n.setCanBeBlank(true);

		Vector vtr = createPdNLessonScores();
		n.setMemberTable( vtr );

		vtrTable.add(n);
		return vtrTable;
	}
	
	/**
	 * cmi.student_data.attempt_records.n データを生成する<br>
	 * @return cmi.student_data.attempt_records.n データ
	 */
	private Vector createPdNAttemptRecords() {
		Vector vtrTable = new Vector();
			
		// lesson_scores データを生成する
		CMIElementProto lesson_scores = new CMIElementProto( );
		lesson_scores.setName("lesson_scores");
		lesson_scores.setIsArray(true);
		lesson_scores.setIsSerializable(true);
		lesson_scores.setValueType( CMINoType );

		Vector vtrPdLessonScores = createPdLessonScores();
		lesson_scores.setMemberTable( vtrPdLessonScores );
		
		lesson_scores.setKeyWord("Score");
		vtrTable.add(lesson_scores);

		// lesson_statuses データを生成する
		CMIElementProto lesson_statuses = new CMIElementProto( );
		lesson_statuses.setName("lesson_statuses");
		lesson_statuses.setIsLeaf(true);
		lesson_statuses.setIsArray(true);
		lesson_statuses.setIsSerializable(true);
		lesson_statuses.setValueType( CMIVocabulary );

		Vector vtrPdLessonStatuses = createPdLessonStatuses();
		lesson_statuses.setMemberTable( vtrPdLessonStatuses );
		
		lesson_statuses.setKeyWord("Lesson_Status");
		vtrTable.add(lesson_statuses);		

		return vtrTable;
	}
	
	/**
	 * cmi.student_data.attempt_records データを生成する<br>
	 * @return cmi.student_data.attempt_records データ
	 */
	private Vector createPdAttemptRecords() {
		Vector vtrTable = new Vector();
			
		// n データを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setValueType( CMINoType );

		Vector vtr = createPdNAttemptRecords();
		n.setMemberTable( vtr );
		
		n.setKeyWord("Score");
		vtrTable.add(n);
		
		return vtrTable;
	}
	
	/**
	 * cmi.student_data データを生成する<br>
	 * @return cmi.student_data データ
	 */
	private Vector createPdStData() {
		Vector vtrTable = new Vector();
			
		// attempt_number データを生成する
		CMIElementProto attempt_number = new CMIElementProto( );
		attempt_number.setName("attempt_number");
		attempt_number.setIsLeaf(true);
		attempt_number.setIsReadable(true);
		attempt_number.setIsSerializable(true);
		attempt_number.setValueType( CMIInteger );
		IBeforeInitializer binit_Attempt_number =
									 new BeforeInitializer("binit_Attempt_number");
		attempt_number.setBeforeInitializer(binit_Attempt_number);
		vtrTable.add(attempt_number);
		
		// mastery_score データを生成する
		CMIElementProto mastery_score = new CMIElementProto( );
		mastery_score.setName("mastery_score");
		mastery_score.setIsLeaf( true );
		mastery_score.setIsReadable(true);
		mastery_score.setIsWritable(true);
		mastery_score.setValueType( CMIDecimal );
		vtrTable.add(mastery_score);
		
		// max_time_allowed データを生成する
		CMIElementProto max_time_allowed = new CMIElementProto( );
		max_time_allowed.setName("max_time_allowed");
		max_time_allowed.setIsLeaf( true );
		max_time_allowed.setIsReadable( true );
		max_time_allowed.setIsWritable( true );
		max_time_allowed.setValueType( CMITimespan );
		vtrTable.add(max_time_allowed);
		
		// time_limit_action データを生成する
		CMIElementProto time_limit_action = new CMIElementProto( );
		time_limit_action.setName("time_limit_action");
		time_limit_action.setIsLeaf( true );
		time_limit_action.setIsReadable( true );
		time_limit_action.setIsWritable( true );
		time_limit_action.setValueType( CMIVocabulary );
		vtrTable.add(time_limit_action);
		
		// attempt_records データを生成する
		CMIElementProto attempt_records = new CMIElementProto( );
		attempt_records.setName("attempt_records");
		attempt_records.setIsArray(true);
		attempt_records.setIsSerializable(true);
		attempt_records.setValueType( CMINoType );
		
		Vector vtr = createPdAttemptRecords();
		attempt_records.setMemberTable( vtr );		
		
		vtrTable.add(attempt_records);	
		
		// tries_during_lesson データを生成する
		CMIElementProto tries_during_lesson = new CMIElementProto( );
		tries_during_lesson.setName("tries_during_lesson");
		tries_during_lesson.setIsSession(true);
		tries_during_lesson.setIsLeaf(true);
		tries_during_lesson.setIsReadable(true);
		tries_during_lesson.setValueType( CMIInteger );		
		vtrTable.add(tries_during_lesson);	
		
		// tries データを生成する
		CMIElementProto tries = new CMIElementProto( );
		tries.setName("tries");
		tries.setIsArray(true);
		tries.setValueType( CMIInteger );
		
		Vector vtrPdTries = createPdTries();
		tries.setMemberTable( vtrPdTries );
		IInitializer init_ArrayClear = new Initializer("init_ArrayClear");
		tries.setInitializer( init_ArrayClear );
		vtrTable.add(tries);	

		return vtrTable;
	}		
		
	/**
	 * cmi.objectives.n.attempts.n.score データを生成する<br>
	 * @return cmi.objectives.n.attempts.n.score データ
	 */
	private Vector createPdObjAttemptsScore() {
		Vector vtrTable = new Vector();
			
		// scaled データを生成する
		CMIElementProto scaled = new CMIElementProto( );
		scaled.setName("scaled");
		scaled.setIsSession( true );
		scaled.setIsLeaf( true );
		scaled.setIsReadable( true );
		scaled.setIsWritable( true );
		scaled.setIsSerializable( true );
		scaled.setValueType( CMIDecimal );
		vtrTable.add(scaled);

		// raw データを生成する
		CMIElementProto raw = new CMIElementProto( );
		raw.setName("raw");
		raw.setIsSession( true );
		raw.setIsLeaf( true );
		raw.setIsReadable( true );
		raw.setIsWritable( true );
		raw.setIsSerializable( true );
		raw.setValueType( CMIDecimal );
		raw.setCanBeBlank( true );
		vtrTable.add(raw);
		
		// max データを生成する
		CMIElementProto max = new CMIElementProto( );
		max.setName("max");
		max.setIsSession( true );
		max.setIsLeaf( true );
		max.setIsReadable( true );
		max.setIsWritable( true );
		max.setIsSerializable( true );
		max.setValueType( CMIDecimal );
		max.setCanBeBlank( true );
		vtrTable.add(max);
		
		// min データを生成する
		CMIElementProto min = new CMIElementProto( );
		min.setName("min");
		min.setIsSession( true );
		min.setIsLeaf( true );
		min.setIsReadable( true );
		min.setIsWritable( true );
		min.setIsSerializable( true );
		min.setValueType( CMIDecimal );
		min.setCanBeBlank( true );
		vtrTable.add(min);	
		
		return vtrTable;						
	}
	
	/**
	 * cmi.objectives.n.scores データを生成する<br>
	 * @return cmi.objectives.n.scores データ
	 */
	private Vector createPdNObjAttempts() {
		Vector vtrTable = new Vector();
			
		// score データを生成する
		CMIElementProto score = new CMIElementProto( );
		score.setName("score");
		score.setIsSession(true);
		score.setValueType( CMIInteger );

		Vector vtr = createPdObjAttemptsScore();
		score.setMemberTable( vtr );			

		vtrTable.add(score);
		
		// status データを生成する
		CMIElementProto status = new CMIElementProto( );
		status.setName("status");
		status.setIsSession(true);
		status.setIsLeaf(true);
		status.setIsReadable(true);
		status.setIsWritable(true);
		status.setValueType( CMIVocabulary );
		status.setCanBeBlank(true);
		vtrTable.add(status);	
	
		return vtrTable;
	}

	/**
	 * cmi.objectives.n.attempts データを生成する<br>
	 * @return cmi.objectives.n.attempts データ
	 */
	private Vector createPdObjAttempts() {
		Vector vtrTable = new Vector();
			
		// n データを生成する
		CMIElementProto nPdObjAttempts = new CMIElementProto( );
		nPdObjAttempts.setName("n");
		nPdObjAttempts.setIsSession(true);
		nPdObjAttempts.setIsLeaf(true);
		nPdObjAttempts.setValueType( CMIDecimal );
		nPdObjAttempts.setCanBeBlank(true);

		Vector vtr = createPdNObjAttempts();
		nPdObjAttempts.setMemberTable( vtr );			

		vtrTable.add(nPdObjAttempts);
		return vtrTable;
	}
	
	/**
	 * cmi.objectives.n データを生成する<br>
	 * @return cmi.objectives.n データ
	 */
	private Vector createPdNObjectives() {
		Vector vtrTable = new Vector();
			
		// sid データを生成する
		CMIElementProto sid = new CMIElementProto( );
		sid.setName("sid");
		sid.setIsLeaf(true);
		sid.setIsReadable(true);
		sid.setIsWritable(true);
		sid.setValueType( CMIIdentifier );
		vtrTable.add(sid);
		
		// id データを生成する
		CMIElementProto id = new CMIElementProto( );
		id.setName("id");
		id.setIsLeaf( true );
		id.setIsReadable(true);
		id.setIsWritable(true);
		id.setIsSerializable( true );
		id.setValueType( CMIIdentifier );
		id.setKeyWord("J_ID");
		vtrTable.add(id);
		
		// attempts データを生成する
		CMIElementProto attempts = new CMIElementProto( );
		attempts.setName("attempts");
		attempts.setIsArray(true);
		attempts.setIsReadable(true);
		attempts.setIsWritable(true);
		attempts.setValueType( CMINoType );
		
		Vector vtr = createPdObjAttempts();
		attempts.setMemberTable( vtr );		
		
		attempts.setKeyWord("J_Score");
		IBeforeInitializer binit_ObjAttempts =
								new BeforeInitializer("binit_ObjAttempts");
		attempts.setBeforeInitializer(binit_ObjAttempts);
		vtrTable.add(attempts);	

		// status(success_status) データを生成する
		CMIElementProto status = new CMIElementProto( );
		status.setName("status");
		status.setIsSession( true );
		status.setIsLeaf( true );
		status.setIsReadable( true );
		status.setIsWritable(true);
		status.setIsSerializable( true );
		status.setValueType( CMIVocabulary );
		status.setKeyWord("J_Status");
		IInitializer init_SStatusClear = new Initializer("init_ArrayClear");
		status.setInitializer(init_SStatusClear);
		vtrTable.add(status);

		// cmi.objectives.n.completion.status データを生成する
		CMIElementProto comp_status = new CMIElementProto( );
		comp_status.setName("completion_status");
		comp_status.setIsSession( true );
		comp_status.setIsLeaf( true );
		comp_status.setIsReadable( true );
		comp_status.setIsWritable(true);
		comp_status.setIsSerializable( true );
		comp_status.setValueType( CMIVocabulary );
		comp_status.setKeyWord("J_Status");
		IInitializer init_CStatusClear = new Initializer("init_ArrayClear");
		comp_status.setInitializer(init_CStatusClear);
		vtrTable.add(comp_status);

		// score データを生成する
		CMIElementProto score = new CMIElementProto( );
		score.setName("score");
		score.setIsSession( true );
		score.setIsSerializable( true );
		score.setValueType( CMIDecimal );
	
		Vector vtrPdObjAttemptsScore = createPdObjAttemptsScore();
		score.setMemberTable( vtrPdObjAttemptsScore );	
		
		vtrTable.add(score);
			
		return vtrTable;						
	}			

	/**
	 * cmi.objectives データを生成する<br>
	 * @return cmi.objectives データ
	 */
	private Vector createPdObjectives() {
		Vector vtrTable = new Vector();
			
		// n データを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsSession( true );
		n.setIsSerializable(true);
		n.setValueType( CMIIdentifier );

		Vector vtr = createPdNObjectives();
		n.setMemberTable( vtr );			

		vtrTable.add(n);
		return vtrTable;
	}
	
	/**
	 * cmi.evaluation.comments.n データを生成する<br>
	 * @return cmi.evaluation.comments.n データ
	 */
	private Vector createPdNEvalComments() {
		Vector vtrTable = new Vector();
			
		// course_id データを生成する
		CMIElementProto course_id = new CMIElementProto( );
		course_id.setName("course_id");
		course_id.setIsSession(true);
		course_id.setIsReadable(true);
		course_id.setValueType( CMIIdentifier );
		vtrTable.add(course_id);
		
		// student_id データを生成する
		CMIElementProto student_id = new CMIElementProto( );
		student_id.setName("student_id");
		student_id.setIsSession(true);
		student_id.setIsReadable(true);
		student_id.setValueType( CMIIdentifier );
		vtrTable.add(student_id);
		
		// lesson_id データを生成する
		CMIElementProto lesson_id = new CMIElementProto( );
		lesson_id.setName("lesson_id");
		lesson_id.setIsSession(true);
		lesson_id.setIsReadable(true);
		lesson_id.setValueType( CMIString256 );
		vtrTable.add(lesson_id);
		
		// date データを生成する
		CMIElementProto date = new CMIElementProto( );
		date.setName("date");
		date.setIsLeaf( true );
		date.setIsReadable( true );
		date.setValueType( CMITime );
		vtrTable.add(date);
		
		// time データを生成する
		CMIElementProto time = new CMIElementProto( );
		time.setName("time");
		time.setIsSession(true);
		time.setIsReadable(true);
		time.setValueType(CMITime);
		vtrTable.add(time);	
		
		// location データを生成する
		CMIElementProto location = new CMIElementProto( );
		location.setName("location");
		location.setIsSession( true );
		location.setIsReadable( true );
		location.setValueType( CMIString256 );		
		vtrTable.add(location);	
		
		// content(comment) データを生成する
		CMIElementProto content = new CMIElementProto( );
		content.setName("content");
		content.setIsSession( true );
		content.setIsReadable( true );
		content.setValueType( CMIString4096 );
		vtrTable.add(content);	

		return vtrTable;
	}	

	/**
	 * cmi.evaluation.comments データを生成する<br>
	 * @return cmi.evaluation.comments データ
	 */
	private Vector createPdEvalComments() {
		Vector vtrTable = new Vector();
			
		// n データを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsSession( true );
		n.setValueType( CMIIdentifier );

		Vector vtr = createPdNEvalComments();
		n.setMemberTable( vtr );			

		vtrTable.add(n);
		return vtrTable;
	}
	
	/**
	 * cmi.evaluation データを生成する<br>
	 * @return cmi.evaluation データ
	 */
	private Vector createPdEvaluation() {
		Vector vtrTable = new Vector();
		if ( IS_GLOBAL_MEM ) {
			
			//course_id データを生成する
			CMIElementProto course_id = new CMIElementProto( );
			course_id.setName("course_id");
			course_id.setIsGlobal(true);
			course_id.setIsLeaf( true );
			course_id.setIsReadable( true );
			course_id.setIsWritable(true);
			course_id.setValueType( CMIIdentifier );
			vtrTable.add(course_id);	
			
		} else {

			//course_id データを生成する
			CMIElementProto course_id = new CMIElementProto( );
			course_id.setName("course_id");
			course_id.setIsLeaf( true );
			course_id.setIsReadable( true );
			course_id.setIsWritable(true);
			course_id.setValueType( CMIIdentifier );
			vtrTable.add(course_id);
						
		}		
		
		//lesson_id データを生成する
		CMIElementProto lesson_id = new CMIElementProto( );
		lesson_id.setName("lesson_id");
		lesson_id.setIsLeaf( true );
		lesson_id.setIsReadable( true );
		lesson_id.setIsWritable(true);
		lesson_id.setValueType( CMIIdentifier );
		
		IMaintenancePutParam putElement = 
					new MaintenancePutParam("putElement");
		lesson_id.setMaintenancePutParam(putElement);
		
		IMaintenanceGetParam getElement = 
							new MaintenanceGetParam("getElement");
		lesson_id.setMaintenanceGetParam(getElement);
		
		vtrTable.add(lesson_id);
		
		// date データを生成する
		CMIElementProto date = new CMIElementProto( );
		date.setName("date");
		date.setIsSession( true );
		date.setIsReadable( true );
		date.setValueType( CMIDate );
		vtrTable.add(date);
		
		// file_path データを生成する
		CMIElementProto file_path = new CMIElementProto( );
		file_path.setName("file_path");
		file_path.setIsLeaf( true );
		file_path.setIsReadable( true );
		file_path.setIsWritable( true );
		file_path.setValueType( CMIString4096 );
		vtrTable.add(file_path);
		
		// comments データを生成する
		CMIElementProto comments = new CMIElementProto( );
		comments.setName("comments");
		comments.setIsArray(true);
		comments.setIsReadable( true );
		comments.setIsWritable( true );
		comments.setValueType( CMIString4096 );

		Vector vComment = createPdEvalComments();
		comments.setMemberTable( vComment );
		
		comments.setKeyWord("Comments_File");
		IInitializer init_ArrayClear = new Initializer("init_ArrayClear");
		comments.setInitializer(init_ArrayClear);
		vtrTable.add(comments);
		
		// interactions データを生成する
		CMIElementProto interactions = new CMIElementProto( );
		interactions.setName("interactions");
		interactions.setIsArray(true);
		interactions.setIsReadable( true );
		interactions.setIsWritable( true );
		interactions.setValueType( CMIString4096 );

		Vector vInteract = createPdInteractions();
		interactions.setMemberTable( vInteract );

		interactions.setKeyWord("Interactions_File");
		IInitializer init_IntArrayClear = new Initializer("init_ArrayClear");
		interactions.setInitializer(init_IntArrayClear);
		vtrTable.add(interactions);

		
		// objectives_status データを生成する
		CMIElementProto objectives_status = new CMIElementProto( );
		objectives_status.setName("objectives_status");
		objectives_status.setIsReadable( true );
		objectives_status.setIsWritable(true);
		objectives_status.setValueType( CMIString4096 );
		objectives_status.setKeyWord("Objectives_Status_File");
		vtrTable.add(objectives_status);
		
		// path データを生成する
		CMIElementProto path = new CMIElementProto( );
		path.setName("path");
		path.setIsLeaf( true );
		path.setIsReadable( true );
		path.setIsWritable(true);
		path.setValueType( CMIString4096 );
		path.setKeyWord("Path_File");
		vtrTable.add(path);
		
		// performance データを生成する
		CMIElementProto performance = new CMIElementProto( );
		performance.setName("performance");
		performance.setIsLeaf( true );
		performance.setIsReadable( true );
		performance.setIsWritable(true);
		performance.setValueType( CMIString4096 );
		performance.setKeyWord( "Performance_File" );
		vtrTable.add(performance);	
	
		// parameter データを生成する
		CMIElementProto parameter = new CMIElementProto( );
		parameter.setName("parameter");
		parameter.setIsLeaf( true );
		parameter.setIsReadable( true );
		parameter.setIsWritable(true);
		parameter.setValueType( CMIString4096 );
		vtrTable.add(parameter);
		
		return vtrTable;
	}	


	/**
	 * cmi.comments_from_lms.n データを生成する<br>
	 * @return Vector cmi.comments_from_lms.n データのインスタンス配列
	 */
	private Vector createPdNLmsComments() {
		Vector vtrTable = new Vector();

		// comment データを生成する
		CMIElementProto comment = new CMIElementProto( );
		comment.setName("comment");
		comment.setIsSession( true );
		comment.setIsReadable( true );
		comment.setIsWritable( true );
		comment.setValueType( CMIString4096 );
		vtrTable.add(comment);	

		// location データを生成する
		CMIElementProto location = new CMIElementProto( );
		location.setName("location");
		location.setIsSession( true );
		location.setIsReadable( true );
		location.setIsWritable( true );
		location.setValueType( CMIString256 );
		vtrTable.add(location);	

		// date データを生成する
		CMIElementProto date = new CMIElementProto( );
		date.setName("date_time");
		date.setIsLeaf( true );
		date.setIsReadable( true );
		date.setIsWritable( true );
		date.setValueType( CMITime );
		vtrTable.add(date);

		return vtrTable;
	}

	/**
	 * cmi.comments_from_lms データを生成する<br>
	 * @return Vector cmi.comments_from_lms データのインスタンス配列
	 */
	private Vector createPdLmsComments() {
		Vector vtrTable = new Vector();
			
		// n データを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsSession( true );
		n.setValueType( CMIIdentifier );

		Vector vtr = createPdNLmsComments();
		n.setMemberTable( vtr );			

		vtrTable.add(n);
		return vtrTable;
	}

	/**
	 * cmi.core.score データを生成する<br>
	 * @return cmi.core.score データ
	 */
	private Vector createPdCoreScore() {
		Vector vtrTable = new Vector();

		// scaled データを生成する
		CMIElementProto scaled = new CMIElementProto( );
		scaled.setName("scaled");
		scaled.setIsSession(true);
		scaled.setIsLeaf(true);
		scaled.setIsReadable( true );
		scaled.setIsWritable( true );
		scaled.setIsMandatory(true);
		scaled.setIsSerializable(true);
		scaled.setValueType( CMIDecimal );
		scaled.setCanBeBlank(true);
		scaled.setDefaultData("");
		vtrTable.add(scaled);
			
		// raw データを生成する
		CMIElementProto raw = new CMIElementProto( );
		raw.setName("raw");
		raw.setIsSession(true);
		raw.setIsLeaf(true);
		raw.setIsReadable( true );
		raw.setIsWritable( true );
		raw.setIsMandatory(true);
		raw.setIsSerializable(true);
		raw.setValueType( CMIDecimal );
		raw.setCanBeBlank(true);
		raw.setDefaultData("");
		vtrTable.add(raw);
		
		// max データを生成する
		CMIElementProto max = new CMIElementProto( );
		max.setName("max");
		max.setIsSession(true);
		max.setIsLeaf(true);
		max.setIsReadable( true );
		max.setIsWritable( true );
		max.setIsSerializable(true);
		max.setValueType( CMIDecimal );
		max.setCanBeBlank(true);
		vtrTable.add(max);
		
		// min データを生成する
		CMIElementProto min = new CMIElementProto( );
		min.setName("min");
		min.setIsSession(true);
		min.setIsLeaf(true);
		min.setIsReadable( true );
		min.setIsWritable( true );
		min.setIsSerializable(true);
		min.setValueType( CMIDecimal );
		min.setCanBeBlank(true);
		vtrTable.add(min);	
		
		return vtrTable;						
	}

	/**
	 * cmi.core データを生成する<br>
	 * @return cmi.core データ
	 */
	private Vector createPdCore() {
		Vector vtrTable = new Vector();
		if ( IS_GLOBAL_MEM ) {
			
			// student_id データを生成する
			CMIElementProto student_id = new CMIElementProto( );
			student_id.setName("student_id");
			student_id.setScorm13Name("learner_id");
			student_id.setIsGlobal(true);
			student_id.setIsLeaf( true );
			student_id.setIsReadable( true );
			student_id.setIsWritable(true);
			student_id.setIsMandatory(true);
			student_id.setValueType( CMIIdentifier );
			IMaintenancePutParam putElement = 
										new MaintenancePutParam("putElement");
			student_id.setMaintenancePutParam(putElement);
			IMaintenanceGetParam getElement =
										new MaintenanceGetParam("getElement");
			student_id.setMaintenanceGetParam(getElement);
			vtrTable.add(student_id);	
			
			// student_name データを生成する
			CMIElementProto student_name = new CMIElementProto( );
			student_name.setName("student_name");
			student_name.setScorm13Name("learner_name");
			student_name.setIsGlobal(true);
			student_name.setIsLeaf( true );
			student_name.setIsReadable( true );
			student_name.setIsWritable(true);
			student_name.setIsMandatory(true);
			student_name.setValueType( CMIString256 );

			IMaintenancePutParam putElementStudent = 
										new MaintenancePutParam("putElement");
			student_name.setMaintenancePutParam(putElementStudent);
			IMaintenanceGetParam getElementStudent =
										new MaintenanceGetParam("getElement");
			student_name.setMaintenanceGetParam(getElementStudent);

			vtrTable.add(student_name);	
			
		} else {
			
			// student_id データを生成する
			CMIElementProto student_id = new CMIElementProto( );
			student_id.setName("student_id");
			student_id.setScorm13Name("learner_id");
			student_id.setIsLeaf( true );
			student_id.setIsReadable( true );
			student_id.setIsWritable(true);
			student_id.setIsMandatory(true);
			student_id.setValueType( CMIIdentifier );
			
			IMaintenancePutParam putElementStudentId = 
										new MaintenancePutParam("putElement");
			student_id.setMaintenancePutParam(putElementStudentId);
			IMaintenanceGetParam getElementStudentId =
										new MaintenanceGetParam("getElement");
			student_id.setMaintenanceGetParam(getElementStudentId);

			vtrTable.add(student_id);	
			
			// student_name データを生成する
			CMIElementProto student_name = new CMIElementProto( );
			student_name.setName("student_name");
			student_name.setScorm13Name("learner_name");
			student_name.setIsLeaf( true );
			student_name.setIsReadable( true );
			student_name.setIsWritable(true);
			student_name.setIsMandatory(true);
			student_name.setValueType( CMIString256 );
			
			IMaintenancePutParam putElementStudentName = 
										new MaintenancePutParam("putElement");
			student_name.setMaintenancePutParam(putElementStudentName);
			IMaintenanceGetParam getElementStudentName =
										new MaintenanceGetParam("getElement");
			student_name.setMaintenanceGetParam(getElementStudentName);			

			vtrTable.add(student_name);	
						
		}		
		
		// lesson_location データを生成する
		CMIElementProto lesson_location = new CMIElementProto( );
		lesson_location.setName("lesson_location");
		lesson_location.setScorm13Name("location");
		lesson_location.setIsLeaf( true );
		lesson_location.setIsReadable( true );
		lesson_location.setIsWritable(true);
		lesson_location.setIsMandatory(true);
		lesson_location.setIsSerializable(true);
		lesson_location.setValueType( CMIString1000 );
		lesson_location.setDefaultData(""); //初期値はnull
		
		IMaintenancePutParam putElementLesson= 
									new MaintenancePutParam("putElement");
		lesson_location.setMaintenancePutParam(putElementLesson);
		IMaintenanceGetParam getElementLesson =
									new MaintenanceGetParam("getElement");
		lesson_location.setMaintenanceGetParam(getElementLesson);			

		vtrTable.add(lesson_location);
		
		// credit データを生成する
		CMIElementProto credit = new CMIElementProto( );
		credit.setName("credit");
		credit.setIsSession( true );
		credit.setIsLeaf( true );
		credit.setIsReadable( true );
		credit.setIsWritable(true);
		credit.setIsMandatory(true);
		credit.setValueType( CMIVocabulary );
		credit.setDefaultData("Credit");
		
		IInitializer init_credit = new Initializer("init_Credit");
		credit.setInitializer(init_credit);
		
		IMaintenancePutParam putElementCredit= 
									new MaintenancePutParam("putElement");
		credit.setMaintenancePutParam(putElementCredit);
		IMaintenanceGetParam getElementCredit =
									new MaintenanceGetParam("getElement");
		credit.setMaintenanceGetParam(getElementCredit);		

		vtrTable.add(credit);

		// completion_status データを生成する
		CMIElementProto comp_status = new CMIElementProto( );
		comp_status.setName("completion_status");
		comp_status.setIsSession(true);
		comp_status.setIsLeaf( true );
		comp_status.setIsReadable( true );
		comp_status.setIsWritable(true);
		comp_status.setIsMandatory(true);
		comp_status.setIsSerializable(true);
		comp_status.setValueType( CMIVocabulary );
		comp_status.setDefaultData( "unknown" );
		
		IMaintenancePutParam putElementC= 
									new MaintenancePutParam("putElement");
		comp_status.setMaintenancePutParam(putElementC);
		IMaintenanceGetParam getElementC =
									new MaintenanceGetParam("getElement");
		comp_status.setMaintenanceGetParam(getElementC);			

		vtrTable.add(comp_status);
		
		// success_status/lesson_status データを生成する
		CMIElementProto lesson_status = new CMIElementProto( );
		lesson_status.setName("lesson_status");
		lesson_status.setScorm13Name("success_status");
		lesson_status.setIsSession(true);
		lesson_status.setIsLeaf( true );
		lesson_status.setIsReadable( true );
		lesson_status.setIsWritable(true);
		lesson_status.setIsMandatory(true);
		lesson_status.setIsSerializable(true);
		lesson_status.setValueType( CMIVocabulary );
		lesson_status.setDefaultData( "unknown" );
		
		IBeforeInitializer binit_LessonS = new BeforeInitializer("binit_LessonStatus");
		lesson_status.setBeforeInitializer(binit_LessonS);
		
		IMaintenancePutParam putElementL= 
									new MaintenancePutParam("putElement");
		lesson_status.setMaintenancePutParam(putElementL);
		IMaintenanceGetParam getElementL =
									new MaintenanceGetParam("getElement");
		lesson_status.setMaintenanceGetParam(getElementL);			
		 
		IMaintenanceGetValue getvalue_LessonStatus = 
									new MaintenanceGetValue("getvalue_LessonStatus");
		lesson_status.setMaintenanceGetValue(getvalue_LessonStatus);							

		vtrTable.add(lesson_status);
		
		// entry データを生成する
		CMIElementProto entry = new CMIElementProto( );
		entry.setName("entry");
		entry.setIsSession(true);
		entry.setIsLeaf( true );
		entry.setIsReadable( true );
		entry.setIsWritable( true );
		entry.setIsMandatory(true);
		entry.setIsSerializable(true);
		entry.setValueType( CMIVocabulary );
		entry.setDefaultData( "ab-initio" );

		IBeforeInitializer Ibinit_Entry = new BeforeInitializer("binit_Entry");
		entry.setBeforeInitializer(Ibinit_Entry);
		
		IMaintenanceGetParam getElementE =
									new MaintenanceGetParam("getEntry");
		entry.setMaintenanceGetParam(getElementE);	

		vtrTable.add(entry);
		
		// exit データを生成する
		CMIElementProto exit = new CMIElementProto( );
		exit.setName("exit");
		exit.setIsSession(true);
		exit.setIsLeaf( true );
		exit.setIsReadable( true );
		exit.setIsSerializable(true);
		exit.setValueType( CMIVocabulary );
		
		IMaintenancePutParam putElementE= 
									new MaintenancePutParam("putElement");
		exit.setMaintenancePutParam(putElementE);	
	
	
		IMaintenancePutParam IputExit= 
									new MaintenancePutParam("putExit");
		exit.setMaintenancePutParam(IputExit);
			
		vtrTable.add(exit);
		
		// score データを生成する
		CMIElementProto score = new CMIElementProto( );
		score.setName("score");
		score.setIsSerializable( true );
		score.setValueType( CMINoType );
		
		Vector vtr = createPdCoreScore();
		score.setMemberTable( vtr );		

		IMaintenancePutParam IputScore= 
									new MaintenancePutParam("putScore");
		score.setMaintenancePutParam(IputScore);
		
		
		IMaintenanceGetParam IgetScore =
									new MaintenanceGetParam("getScore");
		score.setMaintenanceGetParam(IgetScore);	

		vtrTable.add(score);
		
		// total_time データを生成する
		CMIElementProto total_time = new CMIElementProto( );
		total_time.setName("total_time");
		total_time.setIsLeaf( true );
		total_time.setIsReadable( true );
//		total_time.setIsMandatory(true);
		total_time.setIsSerializable( true );
		total_time.setValueType( CMITimespan ); 
		
//		IInitializer Iinit_TotalTime = new Initializer("init_TotalTime");
//		total_time.setInitializer(Iinit_TotalTime);

		IBeforeInitializer Ibinit_TotalTime = new BeforeInitializer("binit_TotalTime");
		total_time.setBeforeInitializer(Ibinit_TotalTime);

		IMaintenancePutParam IputElement= 
									new MaintenancePutParam("putElement");
		total_time.setMaintenancePutParam(IputElement);
		
		
		IMaintenanceGetParam IgetElementL =
									new MaintenanceGetParam("getElement");
		total_time.setMaintenanceGetParam(IgetElementL);	
		
		vtrTable.add(total_time);
		
		// session_time データを生成する
		CMIElementProto session_time = new CMIElementProto( );
		session_time.setName("session_time");
		session_time.setIsSession(true);
		session_time.setIsLeaf( true );
		session_time.setIsReadable( true );
		session_time.setValueType( CMITimespan ); 
		
		IMaintenancePutParam putElementLST= 
									new MaintenancePutParam("putElement");
		session_time.setMaintenancePutParam(putElementLST);
		
		
		IMaintenanceGetParam getElementLST =
									new MaintenanceGetParam("getElement");
		session_time.setMaintenanceGetParam(getElementLST);
		
		vtrTable.add(session_time);
	
		// lesson_mode データを生成する
		CMIElementProto lesson_mode = new CMIElementProto( );
		lesson_mode.setName("lesson_mode");
		lesson_mode.setScorm13Name("mode");
		lesson_mode.setIsSession(true);
		lesson_mode.setIsLeaf( true );
		lesson_mode.setIsReadable( true );
		lesson_mode.setIsWritable(true);
		lesson_mode.setValueType( CMIVocabulary ); 
		lesson_mode.setDefaultData( "Normal" );
		
		IMaintenancePutParam putElementLM= 
									new MaintenancePutParam("putElement");
		lesson_mode.setMaintenancePutParam(putElementLM);
		
		
		IMaintenanceGetParam getElementLM =
									new MaintenanceGetParam("getElement");
		lesson_mode.setMaintenanceGetParam(getElementLM);

		vtrTable.add(lesson_mode);

		// lesson_id データを生成する
		CMIElementProto lesson_id = new CMIElementProto( );
		lesson_id.setName("lesson_id");
		lesson_id.setIsLeaf( true );
		lesson_id.setIsReadable( true );
		lesson_id.setIsWritable( true );
		lesson_id.setValueType( CMIIdentifier ); 
		
		IMaintenancePutParam putElementLI= 
									new MaintenancePutParam("putElement");
		lesson_id.setMaintenancePutParam(putElementLI);
				
		IMaintenanceGetParam getElementLI =
									new MaintenanceGetParam("getElement");
		lesson_id.setMaintenanceGetParam(getElementLI);
		
		vtrTable.add(lesson_id);

		// NTTR*4
		// completion_threshold データを生成する
		CMIElementProto completion_threshold = new CMIElementProto( );
		completion_threshold.setName("completion_threshold");
		completion_threshold.setIsLeaf( true );
		completion_threshold.setIsReadable( true );
		completion_threshold.setIsWritable( true );
		completion_threshold.setIsMandatory(true);
		completion_threshold.setValueType( CMIDecimal );

		IMaintenanceGetParam getElementCT = new MaintenanceGetParam("getElement");
		completion_threshold.setMaintenanceGetParam(getElementCT);			

		vtrTable.add(completion_threshold);
		
		
		CMIElementProto progress_measure = new CMIElementProto( );
		progress_measure.setName("progress_measure");
		progress_measure.setIsLeaf( true );
		progress_measure.setIsReadable( true );
		progress_measure.setIsWritable(true);
		progress_measure.setIsMandatory(true);
		progress_measure.setIsSerializable(true);
		progress_measure.setValueType( CMIDecimal );
		
		IMaintenancePutParam putElementPM = new MaintenancePutParam("putElement");
		progress_measure.setMaintenancePutParam(putElementPM);
		IMaintenanceGetParam getElementPM = new MaintenanceGetParam("getElement");
		progress_measure.setMaintenanceGetParam(getElementPM);			

		vtrTable.add(progress_measure);

		return vtrTable;
	}	
	
	/**
	 * cmi.launch データを生成する<br>
	 * @return cmi.launch データ
	 */
	private Vector createPdLaunch() {
		Vector vtrTable = new Vector();
		if ( IS_GLOBAL_MEM ) {
			
			// aicc_url データを生成する
			CMIElementProto aicc_url = new CMIElementProto( );
			aicc_url.setName("aicc_url");
			aicc_url.setIsGlobal(true);
			aicc_url.setIsLeaf( true );
			aicc_url.setIsReadable( true );
			aicc_url.setIsWritable( true );
			aicc_url.setIsMandatory(true);
			aicc_url.setValueType( CMINoType );
			aicc_url.setCanBeBlank( true );
			vtrTable.add(aicc_url);	
			
			// aicc_sid_seed データを生成する
			CMIElementProto aicc_sid_seed = new CMIElementProto( );
			aicc_sid_seed.setName("aicc_sid_seed");
			aicc_sid_seed.setIsGlobal(true);
			aicc_sid_seed.setIsLeaf( true );
			aicc_sid_seed.setIsReadable( true );
			aicc_sid_seed.setIsWritable( true );
			aicc_sid_seed.setValueType( CMINoType );
			aicc_sid_seed.setCanBeBlank( true );
			vtrTable.add(aicc_sid_seed);	
			
		} else {
			
			// aicc_url データを生成する
			CMIElementProto aicc_url = new CMIElementProto( );
			aicc_url.setName("aicc_url");
			aicc_url.setIsLeaf( true );
			aicc_url.setIsReadable( true );
			aicc_url.setIsWritable( true );
			aicc_url.setIsMandatory( true );
			aicc_url.setValueType( CMINoType );
			aicc_url.setCanBeBlank( true );
			vtrTable.add(aicc_url);	
			
			// aicc_sid_seed データを生成する
			CMIElementProto aicc_sid_seed = new CMIElementProto( );
			aicc_sid_seed.setName("aicc_sid_seed");
			aicc_sid_seed.setIsLeaf( true );
			aicc_sid_seed.setIsReadable( true );
			aicc_sid_seed.setIsWritable( true );
			aicc_sid_seed.setValueType( CMINoType );
			aicc_sid_seed.setCanBeBlank( true );
			vtrTable.add(aicc_sid_seed);
						
		}		
		
		// cbt_url データを生成する
		CMIElementProto cbt_url = new CMIElementProto( );
		cbt_url.setName("cbt_url");
		cbt_url.setIsLeaf( true );
		cbt_url.setIsReadable( true );
		cbt_url.setIsWritable( true );
		cbt_url.setIsMandatory(true);
		cbt_url.setValueType( CMINoType );
		vtrTable.add(cbt_url);
		
		// launch_params データを生成する
		CMIElementProto launch_params = new CMIElementProto( );
		launch_params.setName("launch_params");
		launch_params.setIsLeaf( true );
		launch_params.setIsReadable( true );
		launch_params.setIsWritable( true );
		launch_params.setValueType( CMINoType );
		launch_params.setCanBeBlank( true );
		vtrTable.add(launch_params);
		
		// aicc_sid データを生成する
		CMIElementProto aicc_sid = new CMIElementProto( );
		aicc_sid.setName("aicc_sid");
		aicc_sid.setIsLeaf( true );
		aicc_sid.setIsReadable( true );
		aicc_sid.setIsWritable( true );
		aicc_sid.setValueType( CMINoType );
		vtrTable.add(aicc_sid);
		
		return vtrTable;
	}
	
	
	/**
	 * cmi データを生成する<br>
	 * @return cmi データ
	 */
	private Vector createPdCmi() {
		Vector vtrTable = new Vector();	
		
		// launch データを生成する
		CMIElementProto launch = new CMIElementProto( );
		launch.setName("launch");
		launch.setValueType( CMINoType );
		
		Vector vtr = createPdLaunch();
		launch.setMemberTable( vtr );
		
		vtrTable.add(launch);	
	
		// core データを生成する
		CMIElementProto core = new CMIElementProto( );
		core.setName("core");
		core.setIsSerializable(true);
		core.setValueType( CMINoType );
		
		Vector vtrPdCore = createPdCore();
		core.setMemberTable( vtrPdCore );
				
		IMaintenancePutParam putElementL= 
									new MaintenancePutParam("putCoreGroup");
		core.setMaintenancePutParam(putElementL);
			
		IMaintenanceGetParam getElementL =
									new MaintenanceGetParam("getCoreGroup");
		core.setMaintenanceGetParam(getElementL);	
		
		IMaintenanceGetPutParam getPutCoreGroupC =
									new MaintenanceGetPutParam("getPutCoreGroup");
		core.setMaintenanceGetPutParam(getPutCoreGroupC);
		vtrTable.add(core);
		
		// suspend_data データを生成する
		CMIElementProto suspend_data = new CMIElementProto( );
		suspend_data.setName("suspend_data");
		suspend_data.setIsLeaf( true );
		suspend_data.setIsReadable( true );
		suspend_data.setIsWritable( true );
		suspend_data.setIsMandatory(true);
		suspend_data.setIsSerializable(true);
		suspend_data.setValueType( CMIString4096 );
		suspend_data.setKeyWord( "Core_Lesson" );
		suspend_data.setDefaultData("");
		
		IMaintenancePutParam putElementLSD= 
									new MaintenancePutParam("putCoreLessonGroup");
		suspend_data.setMaintenancePutParam(putElementLSD);
			
		IMaintenanceGetParam getElementLSD =
									new MaintenanceGetParam("getCoreLessonGroup");
		suspend_data.setMaintenanceGetParam(getElementLSD);	
		
		IMaintenanceGetPutParam getPutCoreGroupSD =
									new MaintenanceGetPutParam("getPutCoreLessonGroup");
		suspend_data.setMaintenanceGetPutParam(getPutCoreGroupSD);		

		vtrTable.add(suspend_data);
		
		// launch_data データを生成する
		CMIElementProto launch_data = new CMIElementProto( );
		launch_data.setName("launch_data");
		launch_data.setIsLeaf( true );
		launch_data.setIsReadable( true );
		launch_data.setIsWritable( true );
		launch_data.setIsMandatory(true);
		launch_data.setValueType( CMIString4096 );
		launch_data.setKeyWord("Core_Vendor");
		
		IMaintenanceGetParam getElementLD =
									new MaintenanceGetParam("getCoreVendorGroup");
		launch_data.setMaintenanceGetParam(getElementLD);	

		vtrTable.add(launch_data);		
		
		// comments データを生成する
		CMIElementProto comments = new CMIElementProto( );
		comments.setName("comments");
		comments.setIsLeaf( true );
		comments.setIsReadable( true );
		comments.setIsWritable(true);
		comments.setValueType( CMIString4096 );

		IMaintenancePutParam putElementC= 
									new MaintenancePutParam("putCommentsGroup");
		comments.setMaintenancePutParam(putElementC);

		IMaintenanceGetParam getElementC =
									new MaintenanceGetParam("getCommentsGroup");
		comments.setMaintenanceGetParam(getElementC);	
		
		IMaintenanceGetPutParam getPutCoreGroupCS =
									new MaintenanceGetPutParam("getPutCommentsGroup");
		comments.setMaintenanceGetPutParam(getPutCoreGroupCS);			
		
		vtrTable.add(comments);
		
		// comments_from_lms データを生成する
		CMIElementProto comments_from_lms = new CMIElementProto( );
		comments_from_lms.setName("comments_from_lms");
		comments_from_lms.setIsArray( true );
		comments_from_lms.setValueType( CMINoType );

		Vector vtrPdCmtLms = createPdLmsComments();
		comments_from_lms.setMemberTable( vtrPdCmtLms );

		vtrTable.add(comments_from_lms);			
	
		// evaluation データを生成する
		CMIElementProto evaluation = new CMIElementProto( );
		evaluation.setName("evaluation");
		evaluation.setValueType( CMINoType );
		
		Vector vtrPdEvl = createPdEvaluation();
		evaluation.setMemberTable( vtrPdEvl );

		IMaintenanceGetParam getElementE =
									new MaintenanceGetParam("getEvaluationGroup");
		evaluation.setMaintenanceGetParam(getElementE);	
				
		vtrTable.add(evaluation);
		
		// objectives データを生成する
		CMIElementProto objectives = new CMIElementProto( );
		objectives.setName("objectives");
		objectives.setIsSerializable(true);
		objectives.setIsArray( true );
		objectives.setValueType( CMINoType );
		
		Vector vtrPdObj = createPdObjectives();
		objectives.setMemberTable( vtrPdObj );
		
		objectives.setKeyWord( "Objectives_Status" );
		
		IMaintenancePutParam putElementCM= 
									new MaintenancePutParam("putObjectivesStatusGroup");
		objectives.setMaintenancePutParam(putElementCM);
			
		IMaintenanceGetParam getElementCM =
									new MaintenanceGetParam("getObjectivesStatusGroup");
		objectives.setMaintenanceGetParam(getElementCM);	
		
		IMaintenanceGetPutParam getPutCoreGroupCM =
									new MaintenanceGetPutParam("getPutObjectivesStatusGroup");
		objectives.setMaintenanceGetPutParam(getPutCoreGroupCM);	

		vtrTable.add(objectives);	
		
		// student_data データを生成する
		CMIElementProto student_data = new CMIElementProto( );
		student_data.setName("student_data");
		student_data.setIsSerializable( true );
		student_data.setValueType( CMINoType );
		
		Vector vtrPdSD = createPdStData();
		student_data.setMemberTable( vtrPdSD );
	
		IMaintenancePutParam putElementSD= 
									new MaintenancePutParam("putStudentDataGroup");
		student_data.setMaintenancePutParam(putElementSD);
			
		IMaintenanceGetParam getElementSD =
									new MaintenanceGetParam("getStudentDataGroup");
		student_data.setMaintenanceGetParam(getElementSD);	
		
		IMaintenanceGetPutParam getPutCoreGroupSDD=
									new MaintenanceGetPutParam("getPutStudentDataGroup");
		student_data.setMaintenanceGetPutParam(getPutCoreGroupSDD);	

		vtrTable.add(student_data);
		
		// student_demographics データを生成する
		CMIElementProto student_demographics = new CMIElementProto( );
		student_demographics.setName("student_demographics");
		student_demographics.setValueType( CMINoType );
		
		Vector vtrPdSt = createPdStDemographics();
		student_demographics.setMemberTable( vtrPdSt );
		IMaintenanceGetParam getStudentDemographicsGroup =
											new MaintenanceGetParam("getStudentDemographicsGroup");
											
		student_demographics.setMaintenanceGetParam(getStudentDemographicsGroup);	
				
		vtrTable.add(student_demographics);
		
		// learner_preference/student_preference データを生成する
		CMIElementProto student_preference = new CMIElementProto( );
		student_preference.setName("student_preference");
		student_preference.setScorm13Name("learner_preference");
		student_preference.setValueType( CMINoType );
		
		Vector vtrPdSP = createPdStPreference();
		student_preference.setMemberTable( vtrPdSP );
		
		student_preference.setKeyWord( "Student_Preferences" );
		
		IMaintenancePutParam putElementSPC= 
									new MaintenancePutParam("putStudentPreferencesGroup");
		student_preference.setMaintenancePutParam(putElementSPC);
			
		IMaintenanceGetParam getElementSPC =
									new MaintenanceGetParam("getStudentPreferencesGroup");
		student_preference.setMaintenanceGetParam(getElementSPC);	
		
		IMaintenanceGetPutParam getPutCoreGroupSDPC=
									new MaintenanceGetPutParam("getPutStudentPreferencesGroup");
		student_preference.setMaintenanceGetPutParam(getPutCoreGroupSDPC);	
		vtrTable.add(student_preference);
		
		// interactions データを生成する
		CMIElementProto interactions = new CMIElementProto( );
		interactions.setName("interactions");
		interactions.setIsArray(true);
		interactions.setValueType( CMINoType );
		
		Vector vtrPdI = createPdInteractions();
		interactions.setMemberTable( vtrPdI);
		
		IInitializer init_ArrayClear = new Initializer("init_ArrayClear");
		interactions.setInitializer(init_ArrayClear);
		
		vtrTable.add(interactions);
		
		// paths データを生成する
		CMIElementProto paths = new CMIElementProto( );
		paths.setName("paths");
		paths.setIsArray(true);
		paths.setValueType( CMINoType );
		
		Vector vtrPdPs = createPdPaths();
		paths.setMemberTable( vtrPdPs );
		
		paths.setInitializer(init_ArrayClear);
		vtrTable.add(paths);
		
		// objectives_status データを生成する
		CMIElementProto objectives_status = new CMIElementProto( );
		objectives_status.setName("objectives_status");
		objectives_status.setIsArray(true);
		objectives_status.setValueType( CMINoType );
		
		Vector vtrPdOS = createPdObjectivesStatus();
		objectives_status.setMemberTable( vtrPdOS );
		
		objectives_status.setInitializer(init_ArrayClear);
		vtrTable.add(objectives_status);
		
		return vtrTable;
	}
	
	/**
	 * evaluationData データを生成する<br>
	 * @return evaluationData データ
	 */
	private Vector createPdEvaluationData() {
		Vector vtrTable = new Vector();	
		
		// evaluation データを生成する
		CMIElementProto evaluation = new CMIElementProto( );
		evaluation.setName("evaluation");
		evaluation.setIsArray(true);
		evaluation.setValueType( CMINoType );
		
		Vector vtrPE = createPdEvaluation();
		evaluation.setMemberTable( vtrPE );
		
		vtrTable.add(evaluation);	
	
		// interactions データを生成する
		CMIElementProto interactions = new CMIElementProto( );
		interactions.setName("interactions");
		interactions.setIsArray(true);
		interactions.setIsMandatory(true);
		interactions.setValueType( CMINoType );
		
		Vector vtrPdI = createPdInteractions();
		interactions.setMemberTable( vtrPdI );

		IInitializer init_ArrayClear = new Initializer("init_ArrayClear");
		interactions.setInitializer(init_ArrayClear);

		vtrTable.add(interactions);
		
		// paths データを生成する
		CMIElementProto paths = new CMIElementProto( );
		paths.setName("paths");
		paths.setIsArray(true);
		paths.setValueType( CMINoType );
		
		Vector vtrPdP = createPdPaths();
		paths.setMemberTable( vtrPdP );
				
		paths.setInitializer(init_ArrayClear);
		vtrTable.add(paths);
	
		// objectives_status データを生成する
		CMIElementProto objectives_status = new CMIElementProto( );
		objectives_status.setName("objectives_status");
		objectives_status.setIsArray(true);
		objectives_status.setValueType( CMINoType );
		
		Vector vtrPdOS = createPdObjectivesStatus();
		objectives_status.setMemberTable( vtrPdOS );
				
		objectives_status.setInitializer(init_ArrayClear);
		vtrTable.add(objectives_status);
		
		return vtrTable;
	}	
	
	/**
	 * lesson データを生成する<br>
	 * @return lesson データ
	 */
	private Vector createPdLesson() {
		Vector vtrTable = new Vector();	
		
		// core データを生成する
		CMIElementProto core = new CMIElementProto( );
		core.setName("core");
		core.setIsSerializable(true);
		core.setValueType( CMINoType );
		
		Vector vtrPC = createPdCore();
		core.setMemberTable( vtrPC );

		IMaintenancePutParam putElementL= 
									new MaintenancePutParam("putGroup");
		core.setMaintenancePutParam(putElementL);
		
		
		IMaintenanceGetParam getElementL =
									new MaintenanceGetParam("getGroup");
		core.setMaintenanceGetParam(getElementL);	

		vtrTable.add(core);		
	
		// suspend_data データを生成する
		CMIElementProto suspend_data = new CMIElementProto( );
		suspend_data.setName("suspend_data");
		suspend_data.setIsLeaf(true);
		suspend_data.setIsReadable(true);
		suspend_data.setValueType( CMIString4096 );
		suspend_data.setKeyWord("Core_Lesson");	
		
		IMaintenancePutParam putElementSD= 
									new MaintenancePutParam("putGroup");
		suspend_data.setMaintenancePutParam(putElementSD);
		
		
		IMaintenanceGetParam getElementSD =
									new MaintenanceGetParam("getGroup");
		suspend_data.setMaintenanceGetParam(getElementSD);	

		vtrTable.add(suspend_data);
		
		// launch_data データを生成する
		CMIElementProto launch_data = new CMIElementProto( );
		launch_data.setName("launch_data");
		launch_data.setIsLeaf(true);
		launch_data.setIsReadable(true);
		launch_data.setValueType( CMIString4096 );
		launch_data.setKeyWord("Core_Vendor");	
		
		IMaintenancePutParam putElementLD= 
									new MaintenancePutParam("putGroup");
		launch_data.setMaintenancePutParam(putElementLD);
		
		
		IMaintenanceGetParam getElementLD =
									new MaintenanceGetParam("getGroup");
		launch_data.setMaintenanceGetParam(getElementLD);			

		vtrTable.add(launch_data);
		
		// comments データを生成する
		CMIElementProto comments = new CMIElementProto( );
		comments.setName("comments");
		comments.setIsLeaf(true);
		comments.setIsReadable(true);
		comments.setValueType( CMIString4096 );
		
		IMaintenancePutParam putElementCT= 
									new MaintenancePutParam("putGroup");
		comments.setMaintenancePutParam(putElementCT);
		
		
		IMaintenanceGetParam getElementCT =
									new MaintenanceGetParam("getGroup");
		comments.setMaintenanceGetParam(getElementCT);	

		vtrTable.add(comments);
		
		// evaluation データを生成する
		CMIElementProto evaluation = new CMIElementProto( );
		evaluation.setName("evaluation");
		evaluation.setValueType( CMINoType );
		
		Vector vtrPE = createPdEvaluation();
		evaluation.setMemberTable( vtrPE );
	
		IMaintenancePutParam putElementEN= 
									new MaintenancePutParam("putGroup");
		evaluation.setMaintenancePutParam(putElementEN);
		
		
		IMaintenanceGetParam getElementEN =
									new MaintenanceGetParam("getGroup");
		evaluation.setMaintenanceGetParam(getElementEN);

		vtrTable.add(evaluation);
		
		// objectives データを生成する
		CMIElementProto objectives = new CMIElementProto( );
		objectives.setName("objectives");
		objectives.setIsArray(true);
		objectives.setIsSerializable(true);
		objectives.setValueType( CMINoType );
		
		Vector vtrPO = createPdObjectives();
		objectives.setMemberTable( vtrPO );
		
		objectives.setKeyWord("Objectives_Status");
		
		IMaintenancePutParam putElementOB= 
									new MaintenancePutParam("putGroup");
		objectives.setMaintenancePutParam(putElementOB);
		
		
		IMaintenanceGetParam getElementOB =
									new MaintenanceGetParam("getGroup");
		objectives.setMaintenanceGetParam(getElementOB);
		
		vtrTable.add(objectives);
		
		// student_data データを生成する
		CMIElementProto student_data = new CMIElementProto( );
		student_data.setName("student_data");
		student_data.setIsSerializable( true );
		student_data.setValueType(CMINoType);
		
		Vector vtrPdSD = createPdStData();
		student_data.setMemberTable( vtrPdSD );
	
		IMaintenancePutParam putElementSDT= 
									new MaintenancePutParam("putGroup");
		student_data.setMaintenancePutParam(putElementSDT);
		
		
		IMaintenanceGetParam getElementSDT =
									new MaintenanceGetParam("getGroup");
		student_data.setMaintenanceGetParam(getElementSDT);

		vtrTable.add(student_data);
		
		
		// student_demographics データを生成する
		CMIElementProto student_demographics = new CMIElementProto( );
		student_demographics.setName("student_demographics");
		student_demographics.setValueType( CMINoType );
		
		Vector vtrPSD = createPdStDemographics();
		student_demographics.setMemberTable( vtrPSD );
		
		IMaintenancePutParam putElementSDG= 
									new MaintenancePutParam("putGroup");
		student_demographics.setMaintenancePutParam(putElementSDG);
		
		
		IMaintenanceGetParam getElementSDG =
									new MaintenanceGetParam("getGroup");
		student_demographics.setMaintenanceGetParam(getElementSDG);	

		vtrTable.add(student_demographics);

		// student_preference データを生成する
		CMIElementProto student_preference = new CMIElementProto( );
		student_preference.setName("student_preference");
		student_preference.setScorm13Name("learner_preference");
		student_preference.setIsSerializable(true);
		student_preference.setValueType( CMINoType );
		
		Vector vtrPSP = createPdStPreference();
		student_preference.setMemberTable( vtrPSP );
		
		student_preference.setKeyWord("Student_Preferences");
		
		IMaintenancePutParam putElementSP= 
									new MaintenancePutParam("putGroup");
		student_preference.setMaintenancePutParam(putElementSP);
		
		
		IMaintenanceGetParam getElementSP =
									new MaintenanceGetParam("getGroup");
		student_preference.setMaintenanceGetParam(getElementSP);	

		vtrTable.add(student_preference);

		return vtrTable;
	}
	
	/**
	 * launch データを生成する<br>
	 * @return launch データ
	 */
	private Vector createPdGLaunch() {
		Vector vtrTable = new Vector();	
		
		// launch データを生成する
		CMIElementProto launch = new CMIElementProto( );
		launch.setName("launch");
		launch.setValueType( CMINoType );
		
		Vector vtrPL = createPdLaunch();
		launch.setMemberTable( vtrPL );
		
		vtrTable.add(launch);		
		return vtrTable;
	}
	
	/**
	 * g_evaluation データを生成する<br>
	 * @return g_evaluation データ
	 */
	private CMIElementProto createGEvaluationProto() {
		
		// cmi データを生成する
		CMIElementProto cmi = new CMIElementProto( );
		cmi.setName("cmi");
		cmi.setValueType( CMINoType );
		
		Vector vtrPE = createPdEvaluationData();
		cmi.setMemberTable( vtrPE );

		return cmi;
	}		
	
	/**
	 * g_lesson データを生成する<br>
	 * @return g_lesson データ
	 */
	private CMIElementProto createGLessonProto() {
		Vector vtrTable = new Vector();	
		
		// cmi データを生成する
		CMIElementProto cmi = new CMIElementProto( );
		cmi.setName("cmi");
		cmi.setIsSerializable(true);
		cmi.setValueType( CMINoType );
		
		Vector vtrPL = createPdLesson();
		cmi.setMemberTable( vtrPL );

		return cmi;
	}	
	
	/**
	 * launch データを生成する<br>
	 * @return launch データ
	 */
	private CMIElementProto createGLaunchProto() {
		Vector vtrTable = new Vector();	
		
		// cmi データを生成する
		CMIElementProto cmi = new CMIElementProto( );
		cmi.setName("cmi");
		cmi.setValueType( CMINoType );
		
		Vector vtrPGL = createPdGLaunch();
		cmi.setMemberTable( vtrPGL );

		return cmi;
	}	
	
	/**
	 * g_cbt データを生成する<br>
	 * @return g_cbt データ
	 */
	private CMIElementProto createGCbtProto() {
		
		// cmi データを生成する
		CMIElementProto cmi = new CMIElementProto( );
		cmi.setName("cmi");
		cmi.setValueType( CMINoType );
		
		Vector vtrPC = createPdCmi();
		cmi.setMemberTable( vtrPC );

		return cmi;
	}	
	
	/**
	 * cmi.student_preference.windows データを生成する<br>
	 * @return cmi.student_preference.windows データ
	 */
	private Vector createPdGWindows() {
		Vector vtrTable = new Vector();	
		
		// cmi データを生成する
		CMIElementProto n = new CMIElementProto( );
		n.setName("n");
		n.setIsLeaf(true);
		n.setIsReadable(true);
		n.setIsWritable(true);
		n.setIsSerializable(true);
		n.setValueType( CMIIdentifier );
		vtrTable.add(n);		
		return vtrTable;
	}

	/**
	 * cmi.student_preference データを生成する<br>
	 * @return cmi.student_preference データ
	 */
	private Vector createPdGStPreference() {
		Vector vtrTable = new Vector();	
		
		if (IS_GLOBAL_MEM) {
		
			// windows データを生成する
			CMIElementProto windows = new CMIElementProto( );
			windows.setName("windows");
			windows.setIsGlobal(true);
			windows.setIsArray(true);
			windows.setValueType( CMIString256 );
			
			Vector vtrPGW = createPdGWindows();
			windows.setMemberTable( vtrPGW );
			
			windows.setKeyWord("Window");
			vtrTable.add(windows);
					
		} else {
			
			// windows データを生成する
			CMIElementProto windows = new CMIElementProto( );
			windows.setName("windows");
			windows.setIsArray(true);
			windows.setValueType( CMIString256 );
			
			Vector vtrPGW = createPdGWindows();
			windows.setMemberTable( vtrPGW );
			
			windows.setKeyWord("Window");
			vtrTable.add(windows);	
					
		}
		return vtrTable;
	}	

	/**
	 * cmi データを生成する<br>
	 * @return cmi  データ
	 */
	private Vector createPdGCmi() {
		Vector vtrTable = new Vector();	

		// student_preference データを生成する
		CMIElementProto student_preference = new CMIElementProto( );
		student_preference.setName("student_preference");
		student_preference.setValueType( CMINoType );
		
		Vector vtrPGSP = createPdGStPreference();
		student_preference.setMemberTable( vtrPGSP );
		
		student_preference.setKeyWord("Student_Preferences");
		
		IMaintenancePutParam putElementL= 
									new MaintenancePutParam("putStudentPreferencesGroup");
		student_preference.setMaintenancePutParam(putElementL);
		
		
		IMaintenanceGetParam getElementL =
									new MaintenanceGetParam("getStudentPreferencesGroup");
		student_preference.setMaintenanceGetParam(getElementL);	
		
		vtrTable.add(student_preference);	
		
		return vtrTable;
	}	
	
	/**
	 * g_g_cbt データを生成する<br>
	 * @return g_g_cbt  データ
	 */
	private CMIElementProto createGGCbtProto() {

		// student_preference データを生成する
		CMIElementProto cmi = new CMIElementProto( );
		cmi.setName("cmi");
		cmi.setValueType( CMINoType );
		
		Vector vtrPGGC = createPdGCmi();
		cmi.setMemberTable( vtrPGGC );
		
		return cmi;
	}
}
