OTS/OTS_GB/OTSInterface/PartSizeFileClr.cpp

#include "stdafx.h"
#include "PartSizeFileClr.h"

namespace OTSINTERFACE {
	
	CPartSizeFileClr::CPartSizeFileClr()
	{
		m_LpPartSizeFile = new CPartSizeFilePtr(new CPartSizeFile());
	}

	CPartSizeFileClr::CPartSizeFileClr(CPartSizeFilePtr a_pPartSizeFile)							// copy constructor
	{
		if (a_pPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CPartSizeFileClr: invalid pointer"));
			return;
		}

	
			m_LpPartSizeFile = new CPartSizeFilePtr(a_pPartSizeFile);
	
	}

	CPartSizeFileClr::~CPartSizeFileClr()
	{
		if (m_LpPartSizeFile != nullptr)
		{
			delete m_LpPartSizeFile;
			m_LpPartSizeFile = nullptr;
		}
	}
	CPartSizeFileClr::!CPartSizeFileClr()
	{
		if (m_LpPartSizeFile != nullptr)
		{
			delete m_LpPartSizeFile;
			m_LpPartSizeFile = nullptr;
		}
	}
	
	CPartSizeFilePtr CPartSizeFileClr::GetPartSizeFilePtr()
	{
		return *m_LpPartSizeFile;
	}

	String^ CPartSizeFileClr::GetName()
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetName: current CLR point is invalid."));
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = GetPartSizeFilePtr();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetName:invalid pointer."));
			return nullptr;
		}

		CString sPartSize = pPartSizeFile->GetName();

		String^ sPartSizeClr = gcnew String(sPartSize);
		return sPartSizeClr;
	}
	void CPartSizeFileClr::SetName(String^ a_strName)
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetName: current CLR point is invalid."));
			return;
		}

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

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

		pPartSizeFile->SetName(a_strName);
	}

	// version
	String^ CPartSizeFileClr::GetVersion()
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetVersion: current CLR point is invalid."));
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = GetPartSizeFilePtr();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetVersion:invalid pointer."));
			return nullptr;
		}

		CString sVersion = pPartSizeFile->GetVersion();
		String^ sVersionClr = gcnew String(sVersion);
		return sVersionClr;
	}
	void CPartSizeFileClr::SetVersion(String^ a_strVersion)
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetVersion: current CLR point is invalid."));
			return;
		}

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

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

		pPartSizeFile->SetVersion(a_strVersion);
	}

	List<double>^ CPartSizeFileClr::GetPartSizes()
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizes: current CLR point is invalid."));
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = GetPartSizeFilePtr();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizes:invalid pointer."));
			return nullptr;
		}

		List<double>^ SizeListClr = gcnew List<double>();
		std::vector<double> SizeList = pPartSizeFile->GetSizes();

		for (auto dSize : SizeList)
		{
			SizeListClr->Add(dSize);
		}

		return SizeListClr;
		
	}
		
	void CPartSizeFileClr::SetPartSizes(List<double>^ a_listPartSize, bool a_bClear)
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizes: current CLR point is invalid."));
			return;
		}

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

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

		int nSize = a_listPartSize->Count;
		std::vector<double> SizeList;
		for (int i = 0; i < nSize; i++)
		{
			SizeList.push_back(a_listPartSize[i]);
		}

		pPartSizeFile->SetSizes(SizeList);

	}

	CPartSizeItemListClr^ CPartSizeFileClr::GetPartSizeList()
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeList: current CLR point is invalid."));
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = GetPartSizeFilePtr();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeList:invalid pointer."));
			return nullptr;
		}

		CPartSizeItemListClr^ SizeListClr = gcnew CPartSizeItemListClr();
		CPartSizeItemList SizeItemList = pPartSizeFile->GetPartSizeList();

		for (auto dSizeItem : SizeItemList)
		{
			CPartSizeItemClr^ SizeItemClr = gcnew CPartSizeItemClr(dSizeItem);
			SizeListClr->Add(SizeItemClr);
		}

		return SizeListClr;
	}

	// part size list
	void CPartSizeFileClr::SetPartSizeList(CPartSizeItemListClr^ a_listPartSize, bool a_bClear)
	{
		if (m_LpPartSizeFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeList: current CLR point is invalid."));
			return;
		}

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

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

		int nSize = a_listPartSize->Count;
		CPartSizeItemList SizeList;
		for (int i = 0; i < nSize; i++)
		{
			CPartSizeItemPtr pItem = CPartSizeItemPtr(new CPartSizeItem(a_listPartSize[i]->GetCPartSizeItemPtr().get()));
			SizeList.push_back(pItem);
		}

		pPartSizeFile->SetPartSizeList(SizeList, a_bClear);

	}


	CPartSizeItemClr^ CPartSizeFileClr::GetPartSizeByIndex(int a_nIndex)
	{
		if (m_LpPartSizeFile == nullptr)
		{
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = GetPartSizeFilePtr();
	
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeByIndex: can't get part size file pointer."));
			return nullptr;
		}

		CPartSizeItemPtr pPartSizeItem = pPartSizeFile->GetPartSizeByIndex(a_nIndex);

		ASSERT(pPartSizeItem);
		if (!pPartSizeItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeByIndex: can't get part size item pointer."));
			return nullptr;
		}

		CPartSizeItemClr^ PartSizeItemClr = gcnew CPartSizeItemClr(pPartSizeItem);

		return PartSizeItemClr;
		
	}

	CPartSizeItemClr^ CPartSizeFileClr::GetPartSizeByName(String^ a_strPartSizeName)
	{
		if (m_LpPartSizeFile == nullptr)
		{
			return nullptr;
		}

		CPartSizeFilePtr pPartSizeFile = GetPartSizeFilePtr();

		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeByName: can't get part size file pointer."));
			return nullptr;
		}

		CPartSizeItemPtr pPartSizeItem = pPartSizeFile->GetPartSizeByName(a_strPartSizeName);

		ASSERT(pPartSizeItem);
		if (!pPartSizeItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeByName: can't get part size item pointer."));
			return nullptr;
		}

		CPartSizeItemClr^ PartSizeItemClr = gcnew CPartSizeItemClr(pPartSizeItem);

		return PartSizeItemClr;
	}


}