OTS/OTS_GB/OTSInterface/TriTempItemClr.cpp

#include "stdafx.h"
#include "TriTempItemClr.h"

namespace OTSINTERFACE {

	CTriTempItemClr::CTriTempItemClr()										// constructor
	{
		m_LpTempItem = new CTriTempItemPtr(new CTriTempItem());
	}

	CTriTempItemClr::CTriTempItemClr(CTriTempItemPtr a_pTriTempItem)							// copy constructor
	{
		ASSERT(a_pTriTempItem);
		if (!a_pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CTriTempItemClr: invalid pointer."));
			return;
		}

			m_LpTempItem = new CTriTempItemPtr(a_pTriTempItem);
		
	}

	CTriTempItemClr::~CTriTempItemClr()
	{
		if (m_LpTempItem != nullptr)
		{
			delete m_LpTempItem;
			m_LpTempItem = nullptr;
		}
	}

	CTriTempItemClr::!CTriTempItemClr()
	{
		if (m_LpTempItem != nullptr)
		{
			delete m_LpTempItem;
			m_LpTempItem = nullptr;
		}
	}

	CTriTempItemPtr CTriTempItemClr::GetTriTempItemPtr()
	{
		return *m_LpTempItem;
	}



	// triangle element list
	CTriTempItemElementListClr^ CTriTempItemClr::GetTriTempItemElementList()
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemElementList:empty pointer."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemElementList: invalide pointer."));
			return nullptr;
		}

		CTriTempItemElementList listTriTempItemElement = pTriTempItem->GetTriTempItemElementList();
		CTriTempItemElementListClr^ listTriTempItemElementClr = gcnew CTriTempItemElementListClr();
		for (auto pTriTempItemElement : listTriTempItemElement)
		{
			CTriTempItemElementClr^ TriTempItemElementClr = gcnew CTriTempItemElementClr(pTriTempItemElement);
			listTriTempItemElementClr->Add(TriTempItemElementClr);
		}

		return listTriTempItemElementClr;
	}

	void CTriTempItemClr::SetTriTempItemElementList(CTriTempItemElementListClr^ a_listTriTempItemElement, bool a_bClear)
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempItemElementList:empty pointer."));
			return;
		}

		ASSERT(a_listTriTempItemElement);
		if (!a_listTriTempItemElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempItemElementList: invalid listTriTemp pointer."));
			return;
		}

		CTriTempItemElementList listTriTempItemElement;
		int nSize = a_listTriTempItemElement->Count;
		for (int i = 0; i < nSize; i++)
		{
			CTriTempItemElementPtr pTriTempItemElement = a_listTriTempItemElement[i]->GetTriTempItemElementPtr();
			ASSERT(pTriTempItemElement);
			if (!pTriTempItemElement)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempItemElementList: invalid TriTemp pointer."));
				return;
			}

			listTriTempItemElement.push_back(pTriTempItemElement);
		}
	
		(*m_LpTempItem)->SetTriTempItemElementList(listTriTempItemElement, a_bClear);
		//m_LpTempItem->SetTriTempItemElementList(listTriTempItemElement, a_bClear);
	}

	//element id
	int CTriTempItemClr::GetTemplateID()
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTemplateID: current CLR point is invalid."));
			return -1;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTemplateID:invalid pointer."));
			return -1;
		}

		return pTriTempItem->GetTemplateID();
	}

	void CTriTempItemClr::SetTemplateID(int a_TemplateID)
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTemplateID: current CLR point is invalid."));
			return;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTemplateID:invalid pointer."));
			return;
		}

		pTriTempItem->SetTemplateID(a_TemplateID);
	}

	//template name
	String^ CTriTempItemClr::GetTemplateName()
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTemplateName: current CLR point is invalid."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTemplateName:invalid pointer."));
			return nullptr;
		}

		CString sTriTemp = pTriTempItem->GetTemplateName();

		String^ sTriTempClr = gcnew String(sTriTemp);
		return sTriTempClr;
	}

	void CTriTempItemClr::SetTemplateName(String^ a_strTemplateName)
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTemplateName: current CLR point is invalid."));
			return;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTemplateName:invalid pointer."));
			return;
		}

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

		pTriTempItem->SetTemplateName(a_strTemplateName);
	}

	// top name
	String^ CTriTempItemClr::GetTopName()
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTopName: current CLR point is invalid."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTopName:invalid pointer."));
			return nullptr;
		}

		CString sTopName = pTriTempItem->GetTopName();
		String^ sTopnameClr = gcnew String(sTopName);
		return sTopnameClr;
	}

	void CTriTempItemClr::SetTopName(String^ a_strTopName)
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTopName: current CLR point is invalid."));
			return;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTopName:invalid pointer."));
			return;
		}

		pTriTempItem->SetTopName(a_strTopName);
	}

	// left name
	String^ CTriTempItemClr::GetLeftName()
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetLeftName: current CLR point is invalid."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetLeftName:invalid pointer."));
			return nullptr;
		}

		CString sLeftName = pTriTempItem->GetLeftName();
		String^ sLeftnameClr = gcnew String(sLeftName);
		return sLeftnameClr;
	}
	void CTriTempItemClr::SetLeftName(String^ a_strLeftName)
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLeftName: current CLR point is invalid."));
			return;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLeftName:invalid pointer."));
			return;
		}

		pTriTempItem->SetLeftName(a_strLeftName);
	}

	// right name
	String^ CTriTempItemClr::GetRightName()
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRightName: current CLR point is invalid."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRightName:invalid pointer."));
			return nullptr;
		}

		CString sRightName = pTriTempItem->GetRightName();
		String^ sRightnameClr = gcnew String(sRightName);
		return sRightnameClr;
	}
	void CTriTempItemClr::SetRightName(String^ a_strRightName)
	{
		if (m_LpTempItem == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRightName: current CLR point is invalid."));
			return;
		}

		CTriTempItemPtr pTriTempItem = GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRightName:invalid pointer."));
			return;
		}

		pTriTempItem->SetRightName(a_strRightName);
	}
	
}