OTS/OTS_GB/OTSInterface/OTSProgMgrParamFileClr.cpp

#include "stdafx.h"
#include "OTSProgMgrParamFileClr.h"

namespace OTSINTERFACE {

	COTSProgMgrParamFileClr::COTSProgMgrParamFileClr()											// constructor
	{
		m_LpProgMgrParamFile = new COTSProgMgrParamFilePtr(new COTSProgMgrParamFile());
	}
	COTSProgMgrParamFileClr::COTSProgMgrParamFileClr(COTSProgMgrParamFile* a_pSource)					// copy constructor
	{
		if (a_pSource == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSProgMgrParamFileClr: invalid program manager param file pointer."));
			return;
		}

		m_LpProgMgrParamFile = new COTSProgMgrParamFilePtr(new COTSProgMgrParamFile(a_pSource));
	}
	COTSProgMgrParamFileClr::COTSProgMgrParamFileClr(COTSProgMgrParamFilePtr a_pPorgMgrParam)					// copy constructor
	{
		if (a_pPorgMgrParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSProgMgrParamFileClr: invalid program manager param file pointer."));
			return;
		}

		
			m_LpProgMgrParamFile = new COTSProgMgrParamFilePtr(a_pPorgMgrParam);
		

	}
	COTSProgMgrParamFileClr::~COTSProgMgrParamFileClr()
	{
		if (m_LpProgMgrParamFile != nullptr)
		{
			delete m_LpProgMgrParamFile;
			m_LpProgMgrParamFile = nullptr;
		}
	}
	COTSProgMgrParamFileClr::!COTSProgMgrParamFileClr()
	{
		if (m_LpProgMgrParamFile != nullptr)
		{
			delete m_LpProgMgrParamFile;
			m_LpProgMgrParamFile = nullptr;
		}
	}
	COTSProgMgrParamFilePtr COTSProgMgrParamFileClr::GetCOTSProgMgrParamFilePtr()
	{
		return *m_LpProgMgrParamFile;

	}
	
	// get path name													// file pathname
	String^ COTSProgMgrParamFileClr::GetPathName()
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: invalid pointer."));
			return nullptr;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: invalid pointer."));
			return nullptr;
		}

		CString sPathName = pProgMgr->GetPathName();
		String^ PathNameClr = gcnew String(sPathName);

		return PathNameClr;
	}
	// set path name
	void COTSProgMgrParamFileClr::SetPathName(String^ a_strPathName)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: invalid pointer."));
			return;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: invalid pointer."));
			return;
		}

		ASSERT(a_strPathName);
		if (!a_strPathName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: invalid pointer."));
			return;
		}
		pProgMgr->SetPathName(a_strPathName);
	}
	CSEMStageDataClr^ COTSProgMgrParamFileClr::GetStageData()
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStageData: invalid pointer."));
			return nullptr;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStageData: invalid pointer."));
			return nullptr;
		}

		CSEMStageDataPtr pSEMStageData = pProgMgr->GetStageData();
		ASSERT(pSEMStageData);
		if (!pSEMStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStageData: invalid pointer."));
			return nullptr;
		}
		CSEMStageDataClr^ SEMStageDataClr = gcnew CSEMStageDataClr(pSEMStageData);

		return SEMStageDataClr;
	}
	// Set SEM stage data
	bool COTSProgMgrParamFileClr::SetStageData(CSEMStageDataClr^ a_pStageData)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData: invalid pointer."));
			return false;
		}

		ASSERT(a_pStageData);
		if (!a_pStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData:invalid SEM stage data pointer."));
			return false;
		}
		CSEMStageDataPtr pSEMStageData = a_pStageData->GetCSEMStageData();
		ASSERT(pSEMStageData);
		if (!pSEMStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData:invalid SEM stage data pointer."));
			return false;
		}

		COTSProgMgrParamFilePtr pProgFile = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgFile);
		if (!pProgFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData:invalid file pointer."));
			return false;
		}

		pProgFile->SetStageData(pSEMStageData);

		return true;
	}
	CGenParamClr^ COTSProgMgrParamFileClr::GetGenParam()
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenParam: invalid pointer."));
			return nullptr;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenParam: invalid pointer."));
			return nullptr;
		}

		COTSGeneralParametersPtr pGenParam = pProgMgr->GetGenParam();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenParam: invalid pointer."));
			return nullptr;
		}

		CGenParamClr^ pGenParamClr = gcnew CGenParamClr(pGenParam);

		return pGenParamClr;
	}
	// set general parameter
	bool COTSProgMgrParamFileClr::SetGenParam(CGenParamClr^ a_pGenParam)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam: invalid pointer."));
			return false;
		}
		ASSERT(a_pGenParam);
		if (!a_pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam:invalid general param pointer."));
			return false;
		}
		
		COTSGeneralParametersPtr pGenParam = a_pGenParam->GetCOTSGeneralParametersPtr();

		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam:invalid general param pointer."));
			return false;
		}

		COTSProgMgrParamFilePtr pProgFile = GetCOTSProgMgrParamFilePtr();

		ASSERT(pProgFile);
		if (!pProgFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam:invalid file pointer."));
			return false;
		}

		pProgFile->SetGenParam(pGenParam);

		return true;
	}
	COTSImgScanPrmClr^ COTSProgMgrParamFileClr::GetImageScanParam()
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer."));
			return nullptr;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer."));
			return nullptr;
		}

		COTSImageScanParamPtr pImgPrm = pProgMgr->GetImageScanParam();
		ASSERT(pImgPrm);
		if (!pImgPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer."));
			return nullptr;
		}
		COTSImgScanPrmClr^ pImgPrmClr = gcnew COTSImgScanPrmClr(pImgPrm);

		return pImgPrmClr;
	}
	// set image scan parameter
	bool COTSProgMgrParamFileClr::SetImageScanParam(COTSImgScanPrmClr^ a_pImageScanParam)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid pointer."));
			return false;
		}
		ASSERT(a_pImageScanParam);
		if (!a_pImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam:invalid image scan data pointer."));
			return false;
		}
		COTSImageScanParamPtr pIamgeScan = a_pImageScanParam->GetImgScanPrmPtr();

		ASSERT(pIamgeScan);
		if (!pIamgeScan)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam:invalid image scan data pointer."));
			return false;
		}

		COTSProgMgrParamFilePtr pProgFile = GetCOTSProgMgrParamFilePtr();

		ASSERT(pProgFile);
		if (!pProgFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam:invalid file pointer."));
			return false;
		}

		pProgFile->SetImageScanParam(pIamgeScan);

		return true;
	}
	COTSImgProcPrmClr^ COTSProgMgrParamFileClr::GetImageProcParam()
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcParam: invalid pointer."));
			return nullptr;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcParam: invalid pointer."));
			return nullptr;
		}

		COTSImageProcessParamPtr pImgProc = pProgMgr->GetImageProcParam();
		ASSERT(pImgProc);
		if (!pImgProc)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcParam: invalid pointer."));
			return nullptr;
		}
		COTSImgProcPrmClr^ pImgProcClr = gcnew COTSImgProcPrmClr(pImgProc);

		return pImgProcClr;
	}
	// set image process parameter
	bool COTSProgMgrParamFileClr::SetImageProcParam(COTSImgProcPrmClr^ a_pImageProcParam)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam: invalid pointer."));
			return false;
		}
		ASSERT(a_pImageProcParam);
		if (!a_pImageProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam:invalid image proc data pointer."));
			return false;
		}
		COTSImageProcessParamPtr pImageProc = a_pImageProcParam->GetImgPrcPrmPtr();
	
		ASSERT(pImageProc);
		if (!pImageProc)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam:invalid image proc data pointer."));
			return false;
		}

		COTSProgMgrParamFilePtr pProgFile = GetCOTSProgMgrParamFilePtr();

		ASSERT(pProgFile);
		if (!pProgFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData:invalid file pointer."));
			return false;
		}

		pProgFile->SetImageProcParam(pImageProc);

		return true;
	}
	COTSXRayPrmClr^ COTSProgMgrParamFileClr::GetXRayParam()
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer."));
			return nullptr;
		}
		COTSProgMgrParamFilePtr pProgMgr = GetCOTSProgMgrParamFilePtr();
		ASSERT(pProgMgr);
		if (!pProgMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer."));
			return nullptr;
		}

		COTSXRayParamPtr pXrayPrm = pProgMgr->GetXRayParam();
		ASSERT(pXrayPrm);
		if (!pXrayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer."));
			return nullptr;
		}

		COTSXRayPrmClr^ XrayPrmClr = gcnew COTSXRayPrmClr(pXrayPrm);
		return XrayPrmClr;
	}
	// set XRay parameter
	bool COTSProgMgrParamFileClr::SetXRayParam(COTSXRayPrmClr^ a_pXRayParam)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid pointer."));
			return false;
		}
		ASSERT(a_pXRayParam);
		if (!a_pXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam:invalid x ray data pointer."));
			return false;
		}
		COTSXRayParamPtr pXray = a_pXRayParam->GetCOTSXRayPrmPtr();

		ASSERT(pXray);
		if (!pXray)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam:invalid x ray data pointer."));
			return false;
		}

		COTSProgMgrParamFilePtr pProgFile = GetCOTSProgMgrParamFilePtr();

		ASSERT(pProgFile);
		if (!pProgFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData:invalid file pointer."));
			return false;
		}

		pProgFile->SetXRayParam(pXray);

		return true;

	}
	// load program manager file
	bool COTSProgMgrParamFileClr::Load(String^ a_strPathName)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: invalid pointer."));
			return false;
		}
		bool bRet = false;

		COTSProgMgrParamFilePtr pProgMgrFile = GetCOTSProgMgrParamFilePtr();

		ASSERT(pProgMgrFile);
		if (!pProgMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: invalid pointer."));
			return false;
		}

		bRet = pProgMgrFile->Load(a_strPathName);

		return bRet;
	}
	// save program manager file 
	bool COTSProgMgrParamFileClr::Save(String^ a_strPathName)
	{
		if (m_LpProgMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: invalid pointer."));
			return false;
		}
		bool bRet = false;

		COTSProgMgrParamFilePtr pProgMgrFile = GetCOTSProgMgrParamFilePtr();

		ASSERT(pProgMgrFile);
		if (!pProgMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: invalid pointer."));
			return false;
		}

		bRet = pProgMgrFile->Load(a_strPathName);

		return bRet;
	}

	
}