Пример #1
0
// ----------------------------------------------------------------
//	CentDedEkiCont::ContKudari
// ----------------------------------------------------------------
int CentDedEkiCont::ContKudari::size()const 
{
	CentDedEkiCont* pAdaptee = (CentDedEkiCont*)( (char*)this - 
		offsetof( CentDedEkiCont , CentDedEkiCont::m_xContKudari ) ) ;
	
	return pAdaptee->size() ;
}
Пример #2
0
	// ********************************
	//@name 操作
	// ********************************
void CentDedRosen::insert( 
	const CentDedRosen& rosenToAdd_enter ,
	int iEkiIndexToInsert ) 
{
	CentDedRosen rosenToAdd = rosenToAdd_enter ;
	//○組入れ先駅Index小(起点側)・組入れ先Index大(終点側)を決定
	//	○[組入れ先が始発駅]
	//  	○組入れ先駅Index小=-1
	//  	○組入れ先駅Index大=入力された組入れ先の駅Index
	//	○[組入れ先が中間駅]
	//  	○組入れ先駅Index小=入力された組入れ先の駅Index
	//  	○組入れ先駅Index大=入力された組入れ先の駅Index
	//	○[組入れ先が終着駅]
	//  	○組入れ先駅Index小=駅数-1
	//  	○組入れ先駅Index大=駅数
	int iEkiIndexToInsertMin = -1 ;
	int iEkiIndexToInsertMax = -1 ;
	{
		//○[組入れ先が始発駅]
		if ( iEkiIndexToInsert == 0 )
		{
			iEkiIndexToInsertMin = -1 ;
			iEkiIndexToInsertMax = iEkiIndexToInsert ;
		}
		//○[組入れ先が中間駅]
		//	○組入れ先駅Index小=入力された組入れ先の駅Index
		//	○組入れ先駅Index大=入力された組入れ先の駅Index
		else if ( 0 < iEkiIndexToInsert &&
			iEkiIndexToInsert < getCentDedEkiCont()->size() - 1 )
		{
			iEkiIndexToInsertMin = iEkiIndexToInsert ;
			iEkiIndexToInsertMax = iEkiIndexToInsert ;
		}
		//○[組入れ先が終着駅]
		//	○組入れ先駅Index小=駅数-1
		//	○組入れ先駅Index大=駅数
		else
		{
			iEkiIndexToInsertMin = getCentDedEkiCont()->size() - 1 ;
			iEkiIndexToInsertMax = getCentDedEkiCont()->size() ;
		}
	}
	//○[組入れ先が中間駅]なら、その駅を分割
	if ( 0 < iEkiIndexToInsertMin &&
			iEkiIndexToInsertMax < getCentDedEkiCont()->size() - 1 )
	{
		// ○組入れ先駅Index小=入力された組入れ先の駅Index
		// │組入れ先駅Index大=入力された組入れ先の駅Index+1
		iEkiIndexToInsertMax = iEkiIndexToInsertMin + 1 ;

		// ○組入れ先駅Index小と同名駅を、組入れ先駅Index+1の位置に追加
		// │組入れ先駅Index小の駅は下り着時刻
		// │組入れ先駅Index大の駅は上り着時刻
		{
			CentDedEkiCont* pCentDedEkiCont = getCentDedEkiCont() ;
			CentDedEki*	pDedEkiInsertMin = pCentDedEkiCont->getMuPtr()->get( iEkiIndexToInsertMin ) ;
			pCentDedEkiCont->insert( *pDedEkiInsertMin , iEkiIndexToInsertMax ) ;
			CentDedEki*	pDedEkiInsertMax = pCentDedEkiCont->getMuPtr()->get( iEkiIndexToInsertMax ) ;
			pDedEkiInsertMin->setEkijikokukeisiki( CentDedEki::Jikokukeisiki_KudariChaku ) ;
			pDedEkiInsertMax->setEkijikokukeisiki( CentDedEki::Jikokukeisiki_NoboriChaku ) ;
		}

		//○全ダイヤのループ
		CentDedDiaCont* pCentDedDiaCont = &m_CentDedDiaCont ;
		int idxDia ;
		for ( idxDia = 0 ; idxDia < pCentDedDiaCont->size() ; idxDia ++ )
		{
			CentDedDia* pCentDedDia = pCentDedDiaCont->getMuPtr()->get( idxDia ) ;
			//○下り列車全列車のループ
			//│ ○組入れ先駅Order小・組入れ先駅Order大を求める
			{
				CentDedRessyaCont* pCentDedRessyaCont = pCentDedDia->getCentDedRessyaCont( Ressyahoukou_Kudari ) ;
				int iEkiOrderToInsertMin = -1 ;
				int iEkiOrderToInsertMax = -1 ;
				{
					int iEkiOrder1 = pCentDedRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMin ) ;
					int iEkiOrder2 = pCentDedRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMax ) ;
					iEkiOrderToInsertMin = min( iEkiOrder1 , iEkiOrder2 ) ;
					iEkiOrderToInsertMax = max( iEkiOrder1 , iEkiOrder2 ) ;
				}

				for ( int idxRessya = 0 ; idxRessya < pCentDedRessyaCont->size() ; idxRessya ++ )
				{
					CentDedRessya* pCentDedRessya = pCentDedRessyaCont->getMuPtr()->get( idxRessya ) ;
					CentDedEkiJikoku aEkiJikokuToInserMin = pCentDedRessya->getCentDedEkiJikoku( iEkiOrderToInsertMin ) ;
					CentDedEkiJikoku aEkiJikokuToInserMax = pCentDedRessya->getCentDedEkiJikoku( iEkiOrderToInsertMax ) ;

					//│ ○[組入れ先駅Order小が始発駅の列車]
					//│ │組入れ先駅Order大に、組入れ先Order小をコピー
					//│ ↓組入れ先駅Order小は、運行なしとする。
					if ( pCentDedRessya->getSihatsuEki() == iEkiOrderToInsertMin )
					{
						aEkiJikokuToInserMax = aEkiJikokuToInserMin ;
						aEkiJikokuToInserMin.setEkiatsukai( CentDedEkiJikoku::Ekiatsukai_None ) ;
					}
					//│ ○[組入れ先駅Index小が中間駅の列車]
					//│ │ ○組入れ先駅Order大に、組入れ先駅Order小の駅時刻をコピー
					else if ( pCentDedRessya->getSihatsuEki() < iEkiOrderToInsertMin && 
						iEkiOrderToInsertMin < pCentDedRessya->getSyuuchakuEki() ) 
					{
						aEkiJikokuToInserMax = aEkiJikokuToInserMin ;
					}
					//│ ○[組入れ先駅Order小が終着駅の列車]
					//│  組入れ先駅Order小は、そのままとする。
					//│  組入れ先駅Order大は、運行なしとする。
					else if ( pCentDedRessya->getSyuuchakuEki() == iEkiOrderToInsertMin )
					{
						aEkiJikokuToInserMax.setEkiatsukai( CentDedEkiJikoku::Ekiatsukai_None ) ;
					}

					pCentDedRessya->setCentDedEkiJikoku( iEkiOrderToInsertMin , aEkiJikokuToInserMin ) ;
					pCentDedRessya->setCentDedEkiJikoku( iEkiOrderToInsertMax , aEkiJikokuToInserMax ) ;
				}
			}

			//○上り列車全列車のループ
			//   ○組入れ先駅Order小・組入れ先駅Order大を求める
			{
				CentDedRessyaCont* pCentDedRessyaCont = pCentDedDia->getCentDedRessyaCont( Ressyahoukou_Nobori ) ;
				int iEkiOrderToInsertMin = pCentDedRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMin ) ;
				int iEkiOrderToInsertMax = pCentDedRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMax ) ;
				for ( int idxRessya = 0 ; idxRessya < pCentDedRessyaCont->size() ; idxRessya ++ )
				{
					CentDedRessya* pCentDedRessya = pCentDedRessyaCont->getMuPtr()->get( idxRessya ) ;
					CentDedEkiJikoku aEkiJikokuToInserMin = pCentDedRessya->getCentDedEkiJikoku( iEkiOrderToInsertMax ) ;
					CentDedEkiJikoku aEkiJikokuToInserMax = pCentDedRessya->getCentDedEkiJikoku( iEkiOrderToInsertMin ) ;

					//○[組入れ先駅Order大が始発駅の列車]
					//│組入れ先駅Order小は、そのままとする。
					//↓組入れ先駅Order大は、運行なしとする。
					if ( pCentDedRessya->getSihatsuEki() == iEkiOrderToInsertMax )
					{
						aEkiJikokuToInserMax.setEkiatsukai( CentDedEkiJikoku::Ekiatsukai_None ) ;
					}
					//○[組入れ先駅Index大が中間駅の列車]
					//│ ○組入れ先駅Index小に、組入れ先駅Index大の駅時刻をコピー
					//│ ○組入れ先駅Index小の駅時刻を駅時刻形式(着時刻のみ)に合わせて補正
					//│ ○(組入れ先駅Index小の発時刻をNULLに変更)
					//│ ○組入れ先駅Index大の駅時刻を駅時刻形式(発時刻のみ)に合わせて補正
					//↓ ○(組入れ先駅Index大の着時刻をNULLに変更)
					else if ( pCentDedRessya->getSihatsuEki() < iEkiOrderToInsertMax && 
						iEkiOrderToInsertMax < pCentDedRessya->getSyuuchakuEki() ) 
					{
						aEkiJikokuToInserMin = aEkiJikokuToInserMax ;
					}
					//○[組入れ先駅Index大が終着駅の列車]
					//│組入れ先駅Index小に、駅時刻をコピー
					//↓組入れ先駅Index大は、運行なしとする。
					else if ( pCentDedRessya->getSyuuchakuEki() == iEkiOrderToInsertMax )
					{
						aEkiJikokuToInserMin = aEkiJikokuToInserMax ;
						aEkiJikokuToInserMax.setEkiatsukai( CentDedEkiJikoku::Ekiatsukai_None ) ;
					}

					pCentDedRessya->setCentDedEkiJikoku( iEkiOrderToInsertMin , aEkiJikokuToInserMin ) ;
					pCentDedRessya->setCentDedEkiJikoku( iEkiOrderToInsertMax , aEkiJikokuToInserMax ) ;
				}
			}
		}
		//○組入れ先駅Index小の駅時刻を駅時刻形式に合わせて補正
		//│ ◎駅時刻を駅時刻形式に合わせて補正
		//│   ○[駅時刻形式に着時刻あり・発時刻なし、
		//│    │駅時刻に着時刻なし、発時刻あり]
		//│    ↓着時刻には発時刻をコピー、発時刻はNULL。
		//│    ○[駅時刻形式に着時刻なし・発時刻あり
		//│    │駅時刻に着時刻あり、発時刻なし]
		//│    ↓発時刻には着時刻をコピー、着時刻はNULL。
		//│    ○[駅が始発駅・
		//│    │駅時刻形式に着時刻あり・発時刻あり、
		//│    │駅時刻に着時刻あり、発時刻なし]
		//│    ↓発時刻には着時刻をコピー、着時刻はNULL。
		//│    ○[駅が終着駅・
		//│     駅時刻形式に着時刻あり・発時刻あり
		//│     駅時刻に着時刻なし、発時刻あり]
		//│     着時刻には発時刻をコピー、発時刻はNULL。
		//○組入れ先駅Index大の駅時刻を駅時刻形式に合わせて補正
		adjustByEkijikokukeisiki( iEkiIndexToInsertMin ) ;
		adjustByEkijikokukeisiki( iEkiIndexToInsertMax ) ;
	}
	//○[組入れ先が起点駅]なら、その駅の駅時刻形式は[上り着時刻]とする
	//  ○[組入れ先駅Index小=-1,組入れ先駅Index大=0]
	//    組入れ先駅Index大を上り着時刻とする
	//   ○組入れ先駅Index大の駅時刻を駅時刻形式に合わせて補正
	else if ( iEkiIndexToInsertMin == -1 &&
			iEkiIndexToInsertMax == 0 )
	{
		CentDedEkiCont* pCentDedEkiCont = getCentDedEkiCont() ;
		CentDedEki*	pDedEkiInsert = pCentDedEkiCont->getMuPtr()->get( iEkiIndexToInsertMax ) ;
		pDedEkiInsert->setEkijikokukeisiki( CentDedEki::Jikokukeisiki_NoboriChaku ) ;
		adjustByEkijikokukeisiki( iEkiIndexToInsertMax ) ;
	}
	//○[組入れ先が終点駅]なら、その駅の駅時刻形式は[下り着時刻]とする
	//  ○[組入れ先がIndex小=駅数-1 AND 組入れ先駅Index大=駅数]
	//    組入れ先駅Index小を下り着時刻とする
	//   ○組入れ先駅Index小の駅時刻を駅時刻形式に合わせて補正
	else if ( iEkiIndexToInsertMin == getCentDedEkiCont()->size() - 1 &&
			iEkiIndexToInsertMax == getCentDedEkiCont()->size() ) 
	{
		CentDedEkiCont* pCentDedEkiCont = getCentDedEkiCont() ;
		CentDedEki*	pDedEkiInsert = pCentDedEkiCont->getMuPtr()->get( iEkiIndexToInsertMin ) ;
		pDedEkiInsert->setEkijikokukeisiki( CentDedEki::Jikokukeisiki_KudariChaku ) ;
		adjustByEkijikokukeisiki( iEkiIndexToInsertMin ) ;
	}




	//○駅を追加
	//  ○組入れる路線ファイルの駅をすべて追加する。
	//   追加する駅Indexは、組入れ先駅Index小+1。
	//		○[組入れる路線ファイルの起点駅の駅時刻形式が発着以外]
	//		  その駅の駅時刻形式は[上り着時刻]とする
	//		○[組入れる路線ファイルの終点駅の駅時刻形式が発着以外]
	//		  その駅の駅時刻形式は[下り着時刻]とする
	//  ○組入れ先駅Index大に、追加した駅数を加算
	{
		CentDedEkiCont* pCentDedEkiCont = m_pCentDedEkiCont ;
		const CentDedEkiCont* pCentDedEkiContToAdd = rosenToAdd.getCentDedEkiCont() ;
		for ( int idxEki = 0 ; idxEki < pCentDedEkiContToAdd->size() ; idxEki ++ )
		{
			CentDedEki aEki = *pCentDedEkiContToAdd->getMuPtr()->get( idxEki ) ;
			if ( idxEki == 0 && aEki.getEkijikokukeisiki() != CentDedEki::Jikokukeisiki_Hatsuchaku )
			{
				aEki.setEkijikokukeisiki( CentDedEki::Jikokukeisiki_NoboriChaku ) ;
			}
			else if ( idxEki == pCentDedEkiContToAdd->size() - 1 && 
				aEki.getEkijikokukeisiki() != CentDedEki::Jikokukeisiki_Hatsuchaku )
			{
				aEki.setEkijikokukeisiki( CentDedEki::Jikokukeisiki_KudariChaku ) ;
			}

			pCentDedEkiCont->insert( 
				aEki ,
				iEkiIndexToInsertMin + 1 + idxEki ) ;


			iEkiIndexToInsertMax ++ ;

		}
	}

	//○[組入れ先が中間駅]なら、組入れ先駅Indexが途中駅となる列車は、
	//          追加された駅の駅時刻を経由なしにする。
	if ( 0 < iEkiIndexToInsertMin &&
			iEkiIndexToInsertMax < getCentDedEkiCont()->size() - 1 )
	{
		//  ○全列車のループ
		//    ○下り・上りのループ
		//       ○組入れ先駅Order小・組入れ先駅Order大を求める
		//      ○[始発駅が組入れ先駅Order小より前 AND 
		//       終着駅が組入れ先駅Order大より後]
		//       組入れ先駅Order小+1~組入れ先駅Order大-1の駅扱いを
		//       経由なしにする。
		CentDedDiaCont* pCentDedDiaCont = &m_CentDedDiaCont ;
		int idxDia ;
		for ( idxDia = 0 ; idxDia < pCentDedDiaCont->size() ; idxDia ++ )
		{
			CentDedDia* pCentDedDia = pCentDedDiaCont->getMuPtr()->get( idxDia ) ;
			//○下り列車全列車のループ
			//│ ○組入れ先駅Order小・組入れ先駅Order大を求める
			for ( int iRessyahoukou = Ressyahoukou_Kudari ;
				iRessyahoukou <= Ressyahoukou_Nobori ;
				iRessyahoukou ++ )
			{
				ERessyahoukou eRessyahoukou = (ERessyahoukou)iRessyahoukou ;

				CentDedRessyaCont* pCentDedRessyaCont = pCentDedDia->getCentDedRessyaCont( eRessyahoukou ) ;
				int iEkiOrderToInsertMin = -1 ;
				int iEkiOrderToInsertMax = -1 ;
				{
					int iEkiOrder1 = pCentDedRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMin ) ;
					int iEkiOrder2 = pCentDedRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMax ) ;
					iEkiOrderToInsertMin = min( iEkiOrder1 , iEkiOrder2 ) ;
					iEkiOrderToInsertMax = max( iEkiOrder1 , iEkiOrder2 ) ;
				}

				for ( int idxRessya = 0 ; idxRessya < pCentDedRessyaCont->size() ; idxRessya ++ )
				{
					//      ○[始発駅が組入れ先駅Order小より前 AND 
					//       終着駅が組入れ先駅Order大より後]
					//       組入れ先駅Order小+1~組入れ先駅Order大-1の駅扱いを
					//       経由なしにする。
					CentDedRessya* pCentDedRessya = pCentDedRessyaCont->getMuPtr()->get( idxRessya ) ;
					if ( pCentDedRessya->getSihatsuEki() < iEkiOrderToInsertMin && 
						iEkiOrderToInsertMax < pCentDedRessya->getSyuuchakuEki() )
					{

						CentDedEkiJikoku aEkijikokuKeiyunasi( 
							CentDedEkiJikoku::Ekiatsukai_Keiyunasi ,
							CdDedJikoku() , CdDedJikoku() ) ;
						for ( int iEkiOrder = iEkiOrderToInsertMin + 1 ;
							iEkiOrder <= iEkiOrderToInsertMax - 1 ;
							iEkiOrder ++ )
						{
							pCentDedRessya->setCentDedEkiJikoku( iEkiOrder ,aEkijikokuKeiyunasi ) ; 
						}
					}
				}
			}
		}
	}
	//○列車種別のマージ
	//  ○組入れる路線ファイルの列車種別によるループ
	//    ○[同名の列車種別が編集中の路線ファイルに存在しない]列車種別を
	//     編集中の路線ファイルに追加
	//    ○列車種別対照表(組入れる路線ファイルの列車種別Index→
	//     組入れる路線ファイルの列車種別Index の対照表を作成
	deque<int>	arRessyasyubetsuIdx_AddedToThis ;
	{
		CentDedRessyasyubetsuCont* pCentDedRessyasyubetsuCont = this->getCentDedRessyasyubetsuCont() ;
		const CentDedRessyasyubetsuCont* pCentDedRessyasyubetsuContToAdd = rosenToAdd.getCentDedRessyasyubetsuCont() ;
		

		const Mu<const CentDedRessyasyubetsu*>* muCentDedRessyasyubetsuToAdd =
				pCentDedRessyasyubetsuContToAdd->getMuPtr() ;
		for ( int idxToAdd = 0 ; idxToAdd < muCentDedRessyasyubetsuToAdd->size() ; idxToAdd ++ )
		{
			const CentDedRessyasyubetsu* pCentDedRessyasyubetsuToAdd = 
				muCentDedRessyasyubetsuToAdd->get( idxToAdd ) ;

			Mu<CentDedRessyasyubetsu*>* muCentDedRessyasyubetsuThis =
				pCentDedRessyasyubetsuCont->getMuPtr() ;
			int idxThis = 0 ;
			for ( idxThis = 0 ; idxThis < muCentDedRessyasyubetsuThis->size() ; idxThis ++ )
			{
				const CentDedRessyasyubetsu* pCentDedRessyasyubetsuThis = muCentDedRessyasyubetsuThis->get( idxThis ) ;
				if ( pCentDedRessyasyubetsuThis->getSyubetsumei() == 
					pCentDedRessyasyubetsuToAdd->getSyubetsumei() )
				{
					break ;
				}
			}
			//idxThis = 『追加する路線ファイル』の列車種別[idxToAdd] と同名の
			//	thisの列車種別のインデクス。
			//	なければ、  muCentDedRessyasyubetsuThis->size()

			if ( idxThis == muCentDedRessyasyubetsuThis->size() )
			{
				//	同名の種別がない場合は、
				//	this に追加します。
				pCentDedRessyasyubetsuCont->insert( *pCentDedRessyasyubetsuToAdd ) ;
			}
			arRessyasyubetsuIdx_AddedToThis.push_back( idxThis ) ;
		}

	}
	//arRessyasyubetsuIdx_AddedToThis[追加する路線ファイル』の列車種別インデクス] = 
	//	thisの列車種別インデクス

	//○ダイヤのマージ
	//  ○組入れる路線ファイルのダイヤによるループ
	//    ○[同名のダイヤが編集中の路線ファイルに存在しない]空のダイヤを
	//     編集中の路線ファイルに追加
	//    ○ダイヤ対照表(組入れる路線ファイルのダイヤIndex→
	//     組入れる路線ファイルのダイヤIndex の対照表を作成

	deque<int>	arDiaIdx_AddedToThis ;
	{
		CentDedDiaCont* pCentDedDiaCont = this->getCentDedDiaCont() ;
		const CentDedDiaCont* pCentDedDiaContToAdd = rosenToAdd.getCentDedDiaCont() ;
		
		const Mu<const CentDedDia*>* muCentDedDiaToAdd =
				pCentDedDiaContToAdd->getMuPtr() ;
		for ( int idxToAdd = 0 ; idxToAdd < muCentDedDiaToAdd->size() ; idxToAdd ++ )
		{
			const CentDedDia* pCentDedDiaToAdd = 
				muCentDedDiaToAdd->get( idxToAdd ) ;

			Mu<CentDedDia*>* muCentDedDiaThis =
				pCentDedDiaCont->getMuPtr() ;
			int idxThis = 0 ;
			for ( idxThis = 0 ; idxThis < muCentDedDiaThis->size() ; idxThis ++ )
			{
				const CentDedDia* pCentDedDiaThis = muCentDedDiaThis->get( idxThis ) ;
				if ( pCentDedDiaThis->getName() == 
					pCentDedDiaToAdd->getName() )
				{
					break ;
				}
			}
			//idxThis = 『追加する路線ファイル』の列車種別[idxToAdd] と同名の
			//	thisの列車種別のインデクス。
			//	なければ、  muCentDedDiaThis->size()

			if ( idxThis == muCentDedDiaThis->size() )
			{
				//	同名の種別がない場合は、
				//	this に
				//	列車が空のダイヤを追加します。
				//	(ダイヤオブジェクトを直接追加すると、列車も追加されるため、
				//	うまくいきません) 
				CentDedEkiCont* pCentDedEkiCont = this->getCentDedEkiCont() ;
				CentDedRessyasyubetsuCont* pCentDedRessyasyubetsuCont = this->getCentDedRessyasyubetsuCont() ;
				CentDedDia	diaNew( pCentDedEkiCont->size() , pCentDedRessyasyubetsuCont->size() ) ;
				diaNew.setName( pCentDedDiaToAdd->getName() ) ;
				pCentDedDiaCont->insert( diaNew ) ;
			}
			arDiaIdx_AddedToThis.push_back( idxThis ) ;
		}

	}
	//arDiaIdx_AddedToThis[追加する路線ファイル』のダイヤインデクス] = 
	//	thisのダイヤインデクス

	//○組入れる路線ファイルの列車を、編集中の路線ファイルに追加
	//  ○組入れる路線ファイルのダイヤによるループ
	//    ○全列車のループ
	//      ○列車を追加。
	//       追加するダイヤは、ダイヤ対照表にしたがって変換
	//       列車種別Indexは、列車種別対照表に従って変換
	//
	{
		const Mu<const CentDedDia*>* muCentDedDiaToAdd =
			((const CentDedDiaCont*)rosenToAdd.getCentDedDiaCont())->getMuPtr() ;

		for ( int idxDiaToAdd = 0 ; idxDiaToAdd < muCentDedDiaToAdd->size() ; idxDiaToAdd ++ )
		{
			const CentDedDia* pCentDedDiaToAdd = muCentDedDiaToAdd->get( idxDiaToAdd ) ;

			Mu<CentDedDia*>* muCentDedDiaThis =	this->getCentDedDiaCont()->getMuPtr() ;
			CentDedDia* pCentDedDiaThis = muCentDedDiaThis->get( arDiaIdx_AddedToThis[idxDiaToAdd] ) ;
			//pCentDedDiaThis = 列車のコピー先となる CentDedDia ;

			//下り列車→上り列車
			for ( int idxRessyahoukou = (int)Ressyahoukou_Kudari ;
				idxRessyahoukou <= (int)Ressyahoukou_Nobori ;
				idxRessyahoukou ++ )
			{

				ERessyahoukou eRessyahoukou = (ERessyahoukou)idxRessyahoukou ;
				const CentDedRessyaCont* pCentDedRessyaContToAdd = pCentDedDiaToAdd->getCentDedRessyaCont( eRessyahoukou ) ;
				const Mu<const CentDedRessya*>* muCentDedRessyaToAdd = pCentDedRessyaContToAdd->getMuPtr() ;
				CentDedRessyaCont* pCentDedRessyaContThis = pCentDedDiaThis->getCentDedRessyaCont( eRessyahoukou ) ;

				int iEkiOrderToInsert = -1 ;
				if ( eRessyahoukou == Ressyahoukou_Kudari )
				{
					iEkiOrderToInsert = pCentDedRessyaContThis->EkiOrderOfEkiIndex( iEkiIndexToInsertMin + 1 ) ;
				}
				else
				{
					iEkiOrderToInsert = pCentDedRessyaContThis->EkiOrderOfEkiIndex( iEkiIndexToInsertMax - 1 ) ;
				}
				//iEkiOrderToInsert = 組入れる路線ファイルの駅Order0の列車を挿入する、
				//	thisの駅Order

				for ( int idxRessyaToAdd = 0 ; idxRessyaToAdd < muCentDedRessyaToAdd->size() ; idxRessyaToAdd ++ )
				{
					//	現在編集中の路線ファイルに、組入れる路線ファイルの列車を挿入
					//	列車種別・駅時刻は、このあとに修正
					const CentDedRessya* pRessyaToAdd = muCentDedRessyaToAdd->get( idxRessyaToAdd ) ;
					pCentDedRessyaContThis->insert( *pRessyaToAdd ) ;
					CentDedRessya* pRessyaAdded = pCentDedRessyaContThis->getMuPtr()->get( INT_MAX ) ;
					//pRessyaAdded = 組入れる路線ファイルに追加された列車
					//	列車種別・駅時刻は、このあとに修正

					//	列車種別インデクスを、
					//	現在編集中の路線ファイルに合わせて更新。
					pRessyaAdded->setRessyasyubetsuIndex( 
						arRessyasyubetsuIdx_AddedToThis[ pRessyaToAdd->getRessyasyubetsuIndex() ] ) ;

					//	駅時刻を修正
					for ( int iEkiOrder = 0 ; iEkiOrder < pCentDedRessyaContThis->getEkiCount() ; iEkiOrder ++ )
					{
						int iEkiOrderToAdd = iEkiOrder - iEkiOrderToInsert ;
						//iEkiOrderToAdd = thisのiEkiOrderに対応する、
						//	組入れる路線ファイルの駅Order

						if ( 0 <= iEkiOrderToAdd && iEkiOrderToAdd < pCentDedRessyaContToAdd->getEkiCount() )
						{
							//	組入れる路線ファイルの駅Orderに対応する場合は、
							//	組入れる路線ファイルの駅時刻をコピー
							CentDedEkiJikoku aEkiJikokuToAdd = pRessyaToAdd->getCentDedEkiJikoku( iEkiOrderToAdd ) ; 
							pRessyaAdded->setCentDedEkiJikoku( iEkiOrder , aEkiJikokuToAdd ) ; 
						}
						else
						{
							//	組入れる路線ファイルの駅Orderに対応しない駅に対しては、
							//	運行なしを設定
							pRessyaAdded->setCentDedEkiJikoku( iEkiOrder , CentDedEkiJikoku() ) ; 
						}
					}


				}
			}	
		}
	}


	//○[組入れ先駅Index小と組入れ先駅Index小+1で、駅名が同一]駅を併合
	if ( 0 <= iEkiIndexToInsertMin )
	{
		CentDedEkiCont* pCentDedEkiContThis = getCentDedEkiCont() ;
		CentDedEki*	pEkiToInsertMin = pCentDedEkiContThis->getMuPtr()->get( iEkiIndexToInsertMin ) ;
		CentDedEki*	pEkiToInsertMin_1 = pCentDedEkiContThis->getMuPtr()->get( iEkiIndexToInsertMin + 1 ) ;
		if ( pEkiToInsertMin->getEkimei() == pEkiToInsertMin_1->getEkimei() )
		{
			//  ○組入れ先駅Index小の駅時刻形式を発着に変更
			pEkiToInsertMin->setEkijikokukeisiki( CentDedEki::Jikokukeisiki_Hatsuchaku ) ;

			//  ○全ダイヤのループ
			//        ○全下り列車のループ
			//      ○[組入れ先駅Index小が運行なし]
			//       組入れ先駅Index小+1の駅時刻を組入れ先駅Index小にコピー
			//    ○全上り列車のループ
			//      ○[組入れ先駅Index小が運行なし]
			//       組入れ先駅Index小+1の駅時刻を組入れ先駅Index小にコピー
			CentDedDiaCont* pCentDedDiaCont = this->getCentDedDiaCont() ;
			for ( int idxDia = 0 ; idxDia < pCentDedDiaCont->size() ; idxDia ++ )
			{
				CentDedDia* pDia = pCentDedDiaCont->getMuPtr()->get( idxDia ) ;
				for ( int iRessyahoukou = Ressyahoukou_Kudari ;
					iRessyahoukou <= Ressyahoukou_Nobori ;
					iRessyahoukou ++ )
				{
					ERessyahoukou eRessyahoukou = (ERessyahoukou)iRessyahoukou ;

					CentDedRessyaCont* pRessyaCont = pDia->getCentDedRessyaCont( eRessyahoukou ) ;
					int iEkiOrderToInsertMin = pRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMin ) ;
					int iEkiOrderToInsertMin_1 = pRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMin + 1 ) ;
					for ( int idxRessya = 0 ; idxRessya < pRessyaCont->size() ; idxRessya ++ )
					{
						CentDedRessya* pRessya = pRessyaCont->getMuPtr()->get( idxRessya ) ;
						
						CentDedEkiJikoku aEkijikoku = pRessya->getCentDedEkiJikoku( iEkiOrderToInsertMin ) ;
						if ( aEkijikoku.getEkiatsukai() == CentDedEkiJikoku::Ekiatsukai_None )
						{
							aEkijikoku = pRessya->getCentDedEkiJikoku( iEkiOrderToInsertMin_1 ) ;
							pRessya->setCentDedEkiJikoku( iEkiOrderToInsertMin ,aEkijikoku ) ;
						}
					}
				}
			}
			//  ○組入れ先駅Index小+1の駅を削除
			pCentDedEkiContThis->erase( iEkiIndexToInsertMin + 1 ) ;
			iEkiIndexToInsertMax -- ;
		}
	}

	//○[組入れ先駅Index大と組入れ先駅Index大-1で、駅名が同一]駅を併合
	if ( iEkiIndexToInsertMax < getCentDedEkiCont()->size() - 1 )
	{
		CentDedEkiCont* pCentDedEkiContThis = getCentDedEkiCont() ;
		CentDedEki*	pEkiToInsertMax = pCentDedEkiContThis->getMuPtr()->get( iEkiIndexToInsertMax ) ;
		CentDedEki*	pEkiToInsertMax_1 = pCentDedEkiContThis->getMuPtr()->get( iEkiIndexToInsertMax - 1 ) ;
		if ( pEkiToInsertMax->getEkimei() == pEkiToInsertMax_1->getEkimei() )
		{
			//○組入れ先駅Index大の駅時刻形式を発着に変更
			pEkiToInsertMax->setEkijikokukeisiki( CentDedEki::Jikokukeisiki_Hatsuchaku ) ;
			//○全ダイヤのループ
			//  ○全下り列車のループぴ
			//    ○[組入れ先駅Index大が運行なし]
			//     組入れ先駅Index大-1の駅時刻を組入れ先駅Index大にコピー
			//  ○全上り列車のループぴ
			//    ○[組入れ先駅Index大が運行なし]
			//     組入れ先駅Index大-1の駅時刻を組入れ先駅Index大にコピー
			CentDedDiaCont* pCentDedDiaCont = this->getCentDedDiaCont() ;
			for ( int idxDia = 0 ; idxDia < pCentDedDiaCont->size() ; idxDia ++ )
			{
				CentDedDia* pDia = pCentDedDiaCont->getMuPtr()->get( idxDia ) ;
				for ( int iRessyahoukou = Ressyahoukou_Kudari ;
					iRessyahoukou <= Ressyahoukou_Nobori ;
					iRessyahoukou ++ )
				{
					ERessyahoukou eRessyahoukou = (ERessyahoukou)iRessyahoukou ;

					CentDedRessyaCont* pRessyaCont = pDia->getCentDedRessyaCont( eRessyahoukou ) ;
					int iEkiOrderToInsertMax = pRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMax ) ;
					int iEkiOrderToInsertMax_1 = pRessyaCont->EkiOrderOfEkiIndex( iEkiIndexToInsertMax - 1 ) ;
					for ( int idxRessya = 0 ; idxRessya < pRessyaCont->size() ; idxRessya ++ )
					{
						CentDedRessya* pRessya = pRessyaCont->getMuPtr()->get( idxRessya ) ;
						
						CentDedEkiJikoku aEkijikoku = pRessya->getCentDedEkiJikoku( iEkiOrderToInsertMax ) ;
						if ( aEkijikoku.getEkiatsukai() == CentDedEkiJikoku::Ekiatsukai_None )
						{
							aEkijikoku = pRessya->getCentDedEkiJikoku( iEkiOrderToInsertMax_1 ) ;
							pRessya->setCentDedEkiJikoku( iEkiOrderToInsertMax ,aEkijikoku ) ;
						}
					}
				}
			}
			//  ○組入れ先駅Index大-1の駅を削除
			pCentDedEkiContThis->erase( iEkiIndexToInsertMax - 1 ) ;
			iEkiIndexToInsertMax -- ;
		}
	}
	//○、『追加する路線ファイル』のコメントを、『現在編集している路線ファイル』のコメントの末尾に追加。
	{
		string strComment = this->getComment() ;
		strComment += "\n\n" ;
		strComment += rosenToAdd.getComment() ;
		this->setComment( strComment ) ;
	}
}