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

namespace OTSCLRINTERFACE {

	COTSXRayPrmClr::COTSXRayPrmClr()
	{
		m_LpXRayParam = new COTSXRayParamPtr(new COTSXRayParam());
	}
	COTSXRayPrmClr::COTSXRayPrmClr(COTSXRayParam* a_poSource)			// copy constructor
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		m_LpXRayParam = new COTSXRayParamPtr(new COTSXRayParam(a_poSource));

	}
	COTSXRayPrmClr::COTSXRayPrmClr(COTSXRayParamPtr a_pXRayPrm)					// copy constructor
	{
		// input check
		ASSERT(a_pXRayPrm);
		if (!a_pXRayPrm)
		{
			return;
		}

			m_LpXRayParam = new COTSXRayParamPtr(a_pXRayPrm);
	

	}
	COTSXRayPrmClr::!COTSXRayPrmClr()
	{
		if (m_LpXRayParam != nullptr)
		{
			delete m_LpXRayParam;
			m_LpXRayParam = nullptr;			
		}
	}
	COTSXRayPrmClr::~COTSXRayPrmClr() 
	{
		if (m_LpXRayParam != nullptr)
		{
			delete m_LpXRayParam;
			m_LpXRayParam = nullptr;
		}
	}
	// get x-ray pointer
	COTSXRayParamPtr COTSXRayPrmClr::GetCOTSXRayPrmPtr()
	{
		return *m_LpXRayParam;
	}
	// scan mode
	int	COTSXRayPrmClr::GetScanMode() 
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetScanMode: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetScanMode: invalid pointer."));
			return -1;
		}

		return (int)pOTSXRayPrm->GetScanMode();
	}
	void COTSXRayPrmClr::SetScanMode(int a_nVal)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetScanMode: invalid pointer."));
			return;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetScanMode: invalid pointer."));
			return;
		}

		pOTSXRayPrm->SetScanMode(( OTS_X_RAY_SCAN_MODE)a_nVal);
	}

	bool COTSXRayPrmClr::GetShowScanMode()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowScanMode: invalid pointer."));
			return false;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowScanMode: invalid pointer."));
			return false;
		}

		return pOTSXRayPrm->GetShowScanMode();
	}
	void COTSXRayPrmClr::SetShowScanMode(bool a_bValue)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowScanMode: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowScanMode: can't get param pointer."));
			return;
		}

		pXrayParam->SetShowScanMode(a_bValue);
	}
	// scan speed
	int	COTSXRayPrmClr::GetSearchSpeed()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSearchSpeed: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSearchSpeed: invalid pointer."));
			return -1;
		}

		return (int)pOTSXRayPrm->GetSearchSpeed();
	}
	void COTSXRayPrmClr::SetSearchSpeed(int a_nVal) 
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSearchSpeeed: invalid pointer."));
			return;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSearchSpeeed: invalid pointer."));
			return;
		}

		pOTSXRayPrm->SetSearchSpeed(( OTS_THREE_TIES_OPTIONS)a_nVal);
	}
	// search count
	int	COTSXRayPrmClr::GetSearchCount()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSearchCount: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSearchCount: invalid pointer."));
			return -1;
		}
		return pOTSXRayPrm->GetXRaySearchCount();
	}
	void COTSXRayPrmClr::SetSearchCount(int a_nVal)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSearchCount: invalid pointer."));
			return;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSearchCount: invalid pointer."));
			return;
		}

		pOTSXRayPrm->SetXRaySearchCount(a_nVal);
	}

	// analysis speed
	int	COTSXRayPrmClr::GetAnalySpeed()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAnalySpeed: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAnalySpeed: invalid pointer."));
			return -1;
		}
		return (int)pOTSXRayPrm->GetAnalySpeed();
	}
	void COTSXRayPrmClr::SetAnalySpeed(int a_nVal)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetAnalySpeed: invalid pointer."));
			return;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetAnalySpeed: invalid pointer."));
			return;
		}

		pOTSXRayPrm->SetAnalySpeed((OTS_THREE_TIES_OPTIONS)a_nVal);
	}

	bool COTSXRayPrmClr::GetShowSpeed()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowSpeed: invalid pointer."));
			return false;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowSpeed: invalid pointer."));
			return false;
		}

		return pOTSXRayPrm->GetShowSpeed();
	}
	void COTSXRayPrmClr::SetShowSpeed(bool a_bValue)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowSpeed: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowSpeed: can't get param pointer."));
			return;
		}

		pXrayParam->SetShowSpeed(a_bValue);
	}

	// analysis expectation count
	int	COTSXRayPrmClr::GetAnalyExpCount()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAnalyExpCount: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAnalyExpCount: invalid pointer."));
			return -1;
		}
		return pOTSXRayPrm->GetAnalyExpCount();
	}
	void COTSXRayPrmClr::SetAnalyExpCount(int a_nVal)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetAnalyExpCount: invalid pointer."));
			return;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetAnalyExpCount: invalid pointer."));
			return;
		}
		return pOTSXRayPrm->SetAnalyExpCount(a_nVal);
	}
	bool COTSXRayPrmClr::GetShowExpCount()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowExpCount: invalid pointer."));
			return false;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowExpCount: invalid pointer."));
			return false;
		}

		return pOTSXRayPrm->GetShowExpCount();
	}
	void COTSXRayPrmClr::SetShowExpCount(bool a_bValue)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowExpCount: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowExpCount: can't get param pointer."));
			return;
		}

		pXrayParam->SetShowExpCount(a_bValue);
	}
	int COTSXRayPrmClr::GetMidSearchAQTime()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMidSearchAQTime: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMidSearchAQTime: invalid pointer."));
			return -1;
		}
		return pOTSXRayPrm->GetMidSearchAQTime();
	}
	void COTSXRayPrmClr::SetMidSearchAQTime(int a_nMidSearchAQTime)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMidSearchAQTime: invalid pointer."));
			return;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMidSearchAQTime: invalid pointer."));
			return;
		}
		pOTSXRayPrm->SetMidSearchAQTime(a_nMidSearchAQTime);
	}
	int COTSXRayPrmClr::GetLowSearchAQTime()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetLowSearchAQTime: invalid pointer."));
			return -1;
		}

		COTSXRayParamPtr pOTSXRayPrm = GetCOTSXRayPrmPtr();
		ASSERT(pOTSXRayPrm);
		if (!pOTSXRayPrm)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetLowSearchAQTime: invalid pointer."));
			return -1;
		}
		return pOTSXRayPrm->GetLowSearchAQTime();
	}
	void COTSXRayPrmClr::SetLowSearchAQTime(int a_nLowSearchAQTime)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLowSearchAQTime: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLowSearchAQTime: can't get param pointer."));
			return;
		}

		pXrayParam->SetLowSearchAQTime(a_nLowSearchAQTime);

	}
	int COTSXRayPrmClr::GetHighSearchAQTime()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetHighSearchAQTime: empty param pointer."));
			return -1;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetHighSearchAQTime: can't get param pointer."));
			return -1;
		}

		return pXrayParam->GetHighSearchAQTime();

	}
	void COTSXRayPrmClr::SetHightSearchAQTime(int a_nHighSearchAQTime)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetHightSearchAQTime: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetHightSearchAQTime: can't get param pointer."));
			return;
		}

		pXrayParam->SetHightSearchAQTime(a_nHighSearchAQTime);

	}
	
	int COTSXRayPrmClr::GetMidAnalyAQTime()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMidAnalyAQTime: empty param pointer."));
			return -1;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMidAnalyAQTime: can't get param pointer."));
			return -1;
		}

		return pXrayParam->GetMidAnalyAQTime();
	}
	void COTSXRayPrmClr::SetMidAnalyAQTime(int a_nMidAnalyAQTime)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMidAnalyAQTime: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMidAnalyAQTime: can't get param pointer."));
			return;
		}

		pXrayParam->SetMidAnalyAQTime(a_nMidAnalyAQTime);
	}
	int COTSXRayPrmClr::GetLowAnalyAQTime()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetLowAnalyAQTime: empty param pointer."));
			return -1;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetLowAnalyAQTime: can't get param pointer."));
			return -1;
		}

		return pXrayParam->GetLowAnalyAQTime();
	}
	void COTSXRayPrmClr::SetLowAnalyAQTime(int a_nLowAnalyAQTime)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLowSearchAQTime: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLowSearchAQTime: can't get param pointer."));
			return;
		}

		pXrayParam->SetLowAnalyAQTime(a_nLowAnalyAQTime);

	}
	int COTSXRayPrmClr::GetHighAnalyAQTime()
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetHighAnalyAQTime: empty param pointer."));
			return -1;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetHighAnalyAQTime: can't get param pointer."));
			return -1;
		}

		return pXrayParam->GetHighAnalyAQTime();

	}
	void COTSXRayPrmClr::SetHighAnalyAQTime(int a_nHighAnalyAQTime)
	{
		if (m_LpXRayParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLowSearchAQTime: empty param pointer."));
			return;
		}

		COTSXRayParamPtr pXrayParam = GetCOTSXRayPrmPtr();
		ASSERT(pXrayParam);
		if (!pXrayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLowSearchAQTime: can't get param pointer."));
			return;
		}

		pXrayParam->SetHighAnalyAQTime(a_nHighAnalyAQTime);

	}

}