OTS/OTSCPP/OTSClrInterface/ReportCalculateClr/RptParamFileClr.cpp

#include "stdafx.h"
#include "RptParamFileClr.h"
#include <COTSUtilityDllFunExport.h>

namespace OTSCLRINTERFACE {

	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);
	}
	
	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);
	
	}

	
	
	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);
	}

}