OTS/OTS_GB/OTSInterface/MsrParamsClr.cpp

#include "stdafx.h"
#include "MsrParamsClr.h"

namespace OTSINTERFACE {

	CMsrParamsClr::CMsrParamsClr()
	{
		m_LpMsrParams = new CMsrParamsPtr(new CMsrParams());
	}

	CMsrParamsClr::CMsrParamsClr(CMsrParams* a_pMsrParams)					// copy constructor
	{
		ASSERT(a_pMsrParams);
		if (!a_pMsrParams)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CMsrParamsClr: Generate GenParam pointer failed."));
			return;
		}

		m_LpMsrParams = new CMsrParamsPtr(new CMsrParams(a_pMsrParams));
	}

	CMsrParamsClr::CMsrParamsClr(CMsrParamsPtr a_pMsrParams)								// copy constructor
	{
		ASSERT(a_pMsrParams);
		if (!a_pMsrParams)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CMsrParamsClr: invalid pointer"));
			return;
		}

		
			m_LpMsrParams = new CMsrParamsPtr(a_pMsrParams);
	

	}

	CMsrParamsClr::!CMsrParamsClr()
	{
		if (m_LpMsrParams != nullptr)
		{
			delete m_LpMsrParams;
			m_LpMsrParams = nullptr;
		}
	}

	CMsrParamsClr::~CMsrParamsClr()
	{
		if (m_LpMsrParams != nullptr)
		{
			delete m_LpMsrParams;
			m_LpMsrParams = nullptr;
		}
	}

	CMsrParamsPtr CMsrParamsClr::GetMsrParamsPtr()
	{
		return *m_LpMsrParams;
	}

	String^ CMsrParamsClr::GetName()
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetName: invalid pointer"));
		}
		CMsrParamsPtr pGenParam = GetMsrParamsPtr();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetName: invalid pointer"));
		}

		System::String ^StrName = gcnew String((pGenParam->GetName()).GetBuffer());
		return StrName;
	}

	void CMsrParamsClr::SetName(String^ a_strName)
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetName: invalid pointer"));
			return;
		}
		CMsrParamsPtr pGenParam = GetMsrParamsPtr();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetName: invalid pointer"));
			return;
		}
		ASSERT(a_strName);
		if (!a_strName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetName: invalid pointer"));
			return;
		}
		pGenParam->SetName(a_strName);
	}

	CPartSTDDataClr^ CMsrParamsClr::GetPartSTDData()
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSTDData: invalid pointer"));
			return nullptr;
		}
		CMsrParamsPtr pMsrParams = GetMsrParamsPtr();
		ASSERT(pMsrParams);
		if (!pMsrParams)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSTDData: invalid pointer"));
			return nullptr;
		}
		CPartSTDDataPtr pPartSTDData = pMsrParams->GetPartSTDData();
		ASSERT(pPartSTDData);
		if (!pPartSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSTDData: invalid pointer"));
			return nullptr;
		}
		CPartSTDDataClr^ PartSTDDataClr = gcnew CPartSTDDataClr(pPartSTDData);
		return PartSTDDataClr;
	}

	void CMsrParamsClr::SetPartSTDData(CPartSTDDataClr^ a_poPartSTDData)
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid pointer"));
			return;
		}
		CMsrParamsPtr pGenParam = GetMsrParamsPtr();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid pointer"));
			return;
		}
		ASSERT(a_poPartSTDData);
		if (!a_poPartSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid part std lib pointer"));
			return;
		}
		CPartSTDDataPtr pPartSTD = a_poPartSTDData->GetPartSTDDataPtr();
		ASSERT(pPartSTD);
		if (!pPartSTD)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid part std lib pointer"));
			return;
		}
		pGenParam->SetPartSTDData(pPartSTD);
	}

	int CMsrParamsClr::GetSteelTechnology()
	{
		return (int)m_LpMsrParams->get()->GetSteelTechnology ();
	}

	void CMsrParamsClr::SetSteelTechnology(int a_steelTechnology)
	{
		m_LpMsrParams->get()->SetSteelTechnology((STEEL_TECHNOLOGY)a_steelTechnology);
	}

	COTSImgScanPrmClr^ CMsrParamsClr::GetImageScanParam()
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer"));
			return nullptr;
		}
		CMsrParamsPtr pGenParam = GetMsrParamsPtr();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer"));
		}
		COTSImageScanParamPtr pImageScanParam = pGenParam->GetImageScanParam();
		ASSERT(pImageScanParam);
		if (!pImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer"));
		}
		COTSImgScanPrmClr^ OTSImgScanPrmClr = gcnew COTSImgScanPrmClr(pImageScanParam);
		return OTSImgScanPrmClr;
	}

	void CMsrParamsClr::SetImageScanParam(COTSImgScanPrmClr^ a_poImageScanParam)
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: current CLR point is invalid."));
			return;
		}

		ASSERT(a_poImageScanParam);
		if (!a_poImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: measure project file pointer is invalid."));
			return;
		}
	}

	COTSImgProcPrmClr^ CMsrParamsClr::GetImageProcessParam()
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcessParam: invalid pointer"));
			return nullptr;
		}
		CMsrParamsPtr pMsrParams = GetMsrParamsPtr();
		ASSERT(pMsrParams);
		if (!pMsrParams)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcessParam: invalid pointer"));
		}
		COTSImageProcessParamPtr pOTSImgProcPrm = pMsrParams->GetImageProcessParam();
		ASSERT(pOTSImgProcPrm);
		if (!pOTSImgProcPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcessParam: invalid pointer"));
		}
		COTSImgProcPrmClr^ OTSImgProcPrmClr = gcnew COTSImgProcPrmClr(pOTSImgProcPrm);
		return OTSImgProcPrmClr;
	}

	void CMsrParamsClr::SetImageProcessParam(COTSImgProcPrmClr^ a_poImageProcessParam)
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcessParam: invalid pointer"));
			return;
		}
		CMsrParamsPtr pMsrParams = GetMsrParamsPtr();
		ASSERT(pMsrParams);
		if (!pMsrParams)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcessParam: invalid pointer"));
			return;
		}
		ASSERT(a_poImageProcessParam);
		if (!a_poImageProcessParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcessParam: invalid part std lib pointer"));
			return;
		}
		COTSImageProcessParamPtr pOTSImageProcessParam = a_poImageProcessParam->GetImgPrcPrmPtr();
		ASSERT(pOTSImageProcessParam);
		if (!pOTSImageProcessParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcessParam: invalid image process param pointer"));
			return;
		}
		pMsrParams->SetImageProcessParam(pOTSImageProcessParam);
	}

	COTSXRayPrmClr^ CMsrParamsClr::GetXRayParam()
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer"));
			return nullptr;
		}
		CMsrParamsPtr pGenParam = GetMsrParamsPtr();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer"));
		}
		COTSXRayParamPtr pOTSXRayParam = pGenParam->GetXRayParam();
		ASSERT(pOTSXRayParam);
		if (!pOTSXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer"));
		}
		COTSXRayPrmClr^ OTSXRayPrmClr = gcnew COTSXRayPrmClr(pOTSXRayParam);
		return OTSXRayPrmClr;
	}

	void CMsrParamsClr::SetXRayParam(COTSXRayPrmClr^ a_poXRayParam)
	{
		if (m_LpMsrParams == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid pointer"));
			return;
		}
		CMsrParamsPtr pMsrParams = GetMsrParamsPtr();
		ASSERT(pMsrParams);
		if (!pMsrParams)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid pointer"));
			return;
		}
		ASSERT(a_poXRayParam);
		if (!a_poXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid part std lib pointer"));
			return;
		}
		COTSXRayParamPtr pOTSXRayParam = a_poXRayParam->GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayParam);
		if (!pOTSXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid image process param pointer"));
			return;
		}
		pMsrParams->SetXRayParam(pOTSXRayParam);
	}

}