OTS/OTS_GB/OTSInterface/RptParamFileClr.cpp

#include "stdafx.h"
#include "RptParamFileClr.h"

namespace OTSINTERFACE {

	CRptParamFileClr::CRptParamFileClr()											// constructor
	{
		m_LpRptParamFile = new CRptParamFilePtr(new CRptParamFile());
	}
	
	CRptParamFileClr::CRptParamFileClr(CRptParamFilePtr a_pRptParamFile)								// copy constructor
	{
		ASSERT(a_pRptParamFile);
		if (!a_pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CRptParamFileClr: invalide report param file pointer."));
			return;
		}

			m_LpRptParamFile = new CRptParamFilePtr(a_pRptParamFile);
		
	}

	CRptParamFileClr::~CRptParamFileClr()
	{
		if (m_LpRptParamFile != nullptr)
		{
			delete m_LpRptParamFile;
			m_LpRptParamFile = nullptr;
		}
	}
	CRptParamFileClr::!CRptParamFileClr()
	{
		if (m_LpRptParamFile != nullptr)
		{
			delete m_LpRptParamFile;
			m_LpRptParamFile = nullptr;
		}
	}

	CRptParamFilePtr CRptParamFileClr::GetRptParamFilePtr()
	{
		return *m_LpRptParamFile;
	}
	String^ CRptParamFileClr::GetVersion()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetVersion:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetVersion:invalid pointer."));
			return nullptr;
		}

		CString sVersion = pRptParamFile->GetVersion();
		String^ VersionClr = gcnew String(sVersion);

		return VersionClr;
	}
	void CRptParamFileClr::SetVersion(String^ a_strVersion)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetVersion:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetVersion:invalid pointer."));
			return;
		}

		ASSERT(a_strVersion);
		if (!a_strVersion)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetVersion:invalid pointer."));
			return;
		}

		pRptParamFile->SetVersion(a_strVersion);
	}
	// particle size level file folder
	String^ CRptParamFileClr::GetSizeFileFolder()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeFileFolder:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeFileFolder:invalid pointer."));
			return nullptr;
		}

		CString sFolder = pRptParamFile->GetSizeFileFolder();
		String^ FolderClr = gcnew String(sFolder);

		return FolderClr;
	}
	void CRptParamFileClr::SetSizeFileFolder(String^ a_strSizeFileFolder)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeFileFolder:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeFileFolder:invalid pointer."));
			return;
		}

		ASSERT(a_strSizeFileFolder);
		if (!a_strSizeFileFolder)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeFileFolder:invalid pointer."));
			return;
		}

		pRptParamFile->SetSizeFileFolder(a_strSizeFileFolder);
	}
	CPartSizeFileClr^ CRptParamFileClr::GetPartSizeFile()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFile:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFile:invalid pointer."));
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = pRptParamFile->GetPartSizeFile();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFile:invalid pointer."));
			return nullptr;
		}

		CPartSizeFileClr^ PartSizeFileClr = gcnew CPartSizeFileClr(pPartSizeFile);

		return PartSizeFileClr;

	}
	void CRptParamFileClr::SetPartSizeFile(CPartSizeFileClr^ a_pPartSizeFile)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile:invalid pointer."));
			return;
		}

		ASSERT(a_pPartSizeFile);
		if (!a_pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile:invalid pointer."));
			return;
		}

		CPartSizeFilePtr pPartSizeFile = a_pPartSizeFile->GetPartSizeFilePtr();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile:invalid pointer."));
			return;
		}

		pRptParamFile->SetPartSizeFile(pPartSizeFile);

	}
	String^ CRptParamFileClr::GetTrigTempFileFolder()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTrigTempFileFolder:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTrigTempFileFolder:invalid pointer."));
			return nullptr;
		}

		CString sFolder = pRptParamFile->GetTrigTempFileFolder();
		String^ FolderClr = gcnew String(sFolder);

		return FolderClr;
	}
	void CRptParamFileClr::SetTrigTempFileFolder(String^ a_strTrigTempFileFolder)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTrigTempFileFolder: invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTrigTempFileFolder:invalid pointer."));
			return;
		}

		ASSERT(a_strTrigTempFileFolder);
		if (!a_strTrigTempFileFolder)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTrigTempFileFolder:invalid pointer."));
			return;
		}

		pRptParamFile->SetTrigTempFileFolder(a_strTrigTempFileFolder);
	}
	CTriTempFileClr^ CRptParamFileClr::GetTriTempFile()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempFile:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempFile:invalid pointer."));
			return nullptr;
		}

		CTriTempFilePtr pTriTempFile = pRptParamFile->GetTriTempFile();
		ASSERT(pTriTempFile);
		if (!pTriTempFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempFile:invalid pointer."));
			return nullptr;
		}

		CTriTempFileClr^ RptParamFileClr = gcnew CTriTempFileClr(pTriTempFile);

		return RptParamFileClr;

	}
	void CRptParamFileClr::SetTriTempFile(CTriTempFileClr^ a_pTriTempFile)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile:invalid pointer."));
			return;
		}

		ASSERT(a_pTriTempFile);
		if (!a_pTriTempFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile:invalid pointer."));
			return;
		}
		CTriTempFilePtr pTriTempFile = a_pTriTempFile->GetTriTempFilePtr();
		ASSERT(pTriTempFile);
		if (!pTriTempFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile:invalid pointer."));
			return;
		}

		pRptParamFile->SetTriTempFile(pTriTempFile);
	}
	String^ CRptParamFileClr::GetRptTempFileFolder()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRptTempFileFolder:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRptTempFileFolder:invalid pointer."));
			return nullptr;
		}

		CString sFolder = pRptParamFile->GetRptTempFileFolder();
		String^ FolderClr = gcnew String(sFolder);

		return FolderClr;
	}
	void CRptParamFileClr::SetRptTempFileFolder(String^  a_strRptTempFileFolder)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRptTempFileFolder:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRptTempFileFolder:invalid pointer."));
			return;
		}

		ASSERT(a_strRptTempFileFolder);
		if (!a_strRptTempFileFolder)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRptTempFileFolder:invalid pointer."));
			return;
		}

		pRptParamFile->SetRptTempFileFolder(a_strRptTempFileFolder);
	}

	// report template file path
	String^ CRptParamFileClr::GetRptTempFilePath()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRptTempFilePath:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRptTempFilePath:invalid pointer."));
			return nullptr;
		}

		CString sPath = pRptParamFile->GetRptTempFilePath();
		String^ PathClr = gcnew String(sPath);

		return PathClr;
	}
	void CRptParamFileClr::SetRptTempFilePath(String^  a_strRptTempFilePath)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRptTempFilePath:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRptTempFilePath:invalid pointer."));
			return;
		}

		ASSERT(a_strRptTempFilePath);
		if (!a_strRptTempFilePath)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRptTempFilePath:invalid pointer."));
			return;
		}

		pRptParamFile->SetRptTempFilePath(a_strRptTempFilePath);
	}

	// particle STD analysis file folder
	String^ CRptParamFileClr::GetSTDFileFolder()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDFileFolder:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDFileFolder:invalid pointer."));
			return nullptr;
		}

		CString sFolder = pRptParamFile->GetSTDFileFolder();
		String^ FolderClr = gcnew String(sFolder);

		return FolderClr;
	}
	void CRptParamFileClr::SetSTDFileFolder(String^ a_strSTDFileFolder)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDFileFolder:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDFileFolder:invalid pointer."));
			return;
		}

		ASSERT(a_strSTDFileFolder);
		if (!a_strSTDFileFolder)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDFileFolder:invalid pointer."));
			return;
		}

		pRptParamFile->SetSTDFileFolder(a_strSTDFileFolder);
	
	}

	// STD analysis file
	CPartSTDDataClr^ CRptParamFileClr::GetPartSTDData()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSTDData:invalid pointer."));
			return nullptr;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSTDData:invalid pointer."));
			return nullptr;
		}

		CPartSTDDataPtr pPartSTDData = pRptParamFile->GetPartSTDData();
		CPartSTDDataClr^ PartSTDDataClr = gcnew CPartSTDDataClr(pPartSTDData);

		return PartSTDDataClr;
	}
	void CRptParamFileClr::SetPartSTDData(CPartSTDDataClr^ a_pSTDData)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData:invalid pointer."));
			return;
		}

		ASSERT(a_pSTDData);
		if (!a_pSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData:invalid pointer."));
			return;
		}

		CPartSTDDataPtr pPartSTDData = a_pSTDData->GetPartSTDDataPtr();
		ASSERT(pPartSTDData);
		if (!pPartSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData:invalid pointer."));
			return;
		}

		pRptParamFile->SetPartSTDData(pPartSTDData);

	}
	double CRptParamFileClr::GetScale()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetScale:invalid pointer."));
			return 0.0;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetScale:invalid pointer."));
			return 0.0;
		}

		return pRptParamFile->GetScale();
	}
	void CRptParamFileClr::SetScale(double a_dScale)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetScale:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetScale:invalid pointer."));
			return;
		}

		pRptParamFile->SetScal(a_dScale);
	}

	String^ CRptParamFileClr::GetElementsColName()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return "";
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return "";
		}

		CString sElementColName = pRptParamFile->GetElementsColName();
		String^ sElementColNameClr = gcnew String(sElementColName);

		return sElementColNameClr;
	}

	void CRptParamFileClr::SetElementsColName(String^ a_strElementsColName)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return;
		}

		pRptParamFile->SetElementsColName(a_strElementsColName);
	}

	String^ CRptParamFileClr::GetDefaultComputedColName()
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return "";
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return "";
		}

		CString sDefaultComputedColName = pRptParamFile->GetDefaultComputedColName();
		String^ ssDefaultComputedColNameClr = gcnew String(sDefaultComputedColName);

		return ssDefaultComputedColNameClr;
	}

	void CRptParamFileClr::SetDefaultComputedColName(String^ a_strDefaultComputedColName)
	{
		if (m_LpRptParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return;
		}

		CRptParamFilePtr pRptParamFile = GetRptParamFilePtr();
		ASSERT(pRptParamFile);
		if (!pRptParamFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementsColName:invalid pointer."));
			return;
		}

		pRptParamFile->SetDefaultComputedColName(a_strDefaultComputedColName);
	}

}