OTS/OTS_GB/OTSInterface/PartSizeFileMgrClr.cpp

#include "stdafx.h"
#include "PartSizeFileMgrClr.h"

namespace OTSINTERFACE {

	CPartSizeFileMgrClr::CPartSizeFileMgrClr()
	{
		m_LpPartSizeFileMgr = new CPartSizeFileMgrPtr(new CPartSizeFileMgr());
	}

	CPartSizeFileMgrClr::CPartSizeFileMgrClr(CPartSizeFileMgrPtr a_pPartSizeFileMgr)						// copy constructor
	{
		ASSERT(a_pPartSizeFileMgr);
		if (!a_pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CPartSizeFileMgrClr: invalid share pointer."));
			return;
		}

			m_LpPartSizeFileMgr = new CPartSizeFileMgrPtr(a_pPartSizeFileMgr);
		
	}
	
	CPartSizeFileMgrClr::!CPartSizeFileMgrClr()
	{
		if (m_LpPartSizeFileMgr != nullptr)
		{
			delete m_LpPartSizeFileMgr;
			m_LpPartSizeFileMgr = nullptr;
		}
	}

	CPartSizeFileMgrClr::~CPartSizeFileMgrClr()
	{
		if (m_LpPartSizeFileMgr != nullptr)
		{
			delete m_LpPartSizeFileMgr;
			m_LpPartSizeFileMgr = nullptr;
		}
	}

	CPartSizeFileMgrPtr CPartSizeFileMgrClr::GetPartSizeFileMgrPtr()
	{
		return *m_LpPartSizeFileMgr;
	}
	// Load/Save
	bool CPartSizeFileMgrClr::LoadAll(String^ a_strPathName, bool a_bClear)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("LoadAll: invalid pointer."));
			return false;
		}

		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->LoadAll(a_strPathName, a_bClear);
		return bRet;
	}

	bool CPartSizeFileMgrClr::SaveAll(String^ a_strPathName, String^ a_SizeName)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SaveAll: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->SaveAll(a_strPathName, a_SizeName);
		if (bRet)
		{
			CString a = pPartSizeFileMgr.get()->GetPathName();
			SetPathName(gcnew String(a.GetBuffer()));
		}
		return bRet;
	} 

	// Load/Save
	bool CPartSizeFileMgrClr::Load(String^ a_strPathName, bool a_bClear)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->Load(a_strPathName, a_bClear);

		return bRet;
	}
	bool CPartSizeFileMgrClr::Save(String^ a_strPathName)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->Save(a_strPathName);

		return bRet;
	}

	// load/save a part size from a text file
	bool CPartSizeFileMgrClr::LoadPartSizeFromTextFile(String^ a_strFilePathName)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("LoadPartSizeFromTextFile: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("LoadPartSizeFromTextFile: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->LoadPartSizeFromTextFile(a_strFilePathName);
		return bRet;
	}
	bool CPartSizeFileMgrClr::SavePartSizeTextFile(String^ a_strFilePathName)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SavePartSizeTextFile: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SavePartSizeTextFile: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->SavePartSizeTextFile( a_strFilePathName);

		return bRet;
	}

	// std items list

	void CPartSizeFileMgrClr::SetPartSizeItemList(List<double>^ a_listPartSizeItems, bool a_bClear)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeItemList: invalid pointer."));
			return;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

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

		int nSize = a_listPartSizeItems->Count;
		std::vector<double> listPartSizeItem;
		for (int i = 0; i < nSize; i++)
		{
			listPartSizeItem[i] = a_listPartSizeItems[i];
		}

		pPartSizeFileMgr->SetPartSizeItemList(listPartSizeItem, a_bClear);

	}	

	CPartSizeItemClr^ CPartSizeFileMgrClr::GetPartSizeItemByIndex(int a_nIndex)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeItemByIndex: invalid pointer."));
			return nullptr;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

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

		CPartSizeItemPtr pPartSizeItem = pPartSizeFileMgr->GetPartSizeItemByIndex(a_nIndex);

		ASSERT(pPartSizeItem);
		if (!pPartSizeItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeItemByIndex: invalide part size item pointer."));
			return nullptr;
		}

		CPartSizeItemClr^ PartSizeItemClr = gcnew CPartSizeItemClr(pPartSizeItem);

		return PartSizeItemClr;
	}
	CPartSizeItemClr^ CPartSizeFileMgrClr::GetPartSizeItemByName(String^ a_strName)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeItemByName: invalid pointer."));
			return nullptr;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

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

		CPartSizeItemPtr pPartSizeItem = pPartSizeFileMgr->GetPartSizeItemByName(a_strName);

		ASSERT(pPartSizeItem);
		if (!pPartSizeItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeItemByName: invalide part size item pointer."));
			return nullptr;
		}

		CPartSizeItemClr^ PartSizeItemClr = gcnew CPartSizeItemClr(pPartSizeItem);

		return PartSizeItemClr;
	}
	bool CPartSizeFileMgrClr::DeletePartSizeItemByIndex(int a_nIndex)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeletePartSizeItemByIndex: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeletePartSizeItemByIndex: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->DeletePartSizeItemByIndex(a_nIndex);
		
		return bRet;
	}

	bool CPartSizeFileMgrClr::DeletePartSizeItemByPart(double d_Part)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeletePartSizeItemByPart: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeletePartSizeItemByPart: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->DeletePartSizeItemByPart(d_Part);

		return bRet;
	}

	bool CPartSizeFileMgrClr::AddPartSizeItem(double d_Part)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddPartSizeItem: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddPartSizeItem: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->AddPartSizeItem(d_Part);

		return bRet;
	}

	bool CPartSizeFileMgrClr::EditPartSizeItem(int a_nIndex, CPartSizeItemClr^ a_poPartSizeItem)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditPartSizeItem: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();

		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditPartSizeItem: can't get part size file manager pointer."));
			return FALSE;
		}

		CPartSizeItemPtr pPartSizeItem = a_poPartSizeItem->GetCPartSizeItemPtr();
		ASSERT(pPartSizeItem);
		if (!pPartSizeItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditPartSizeItem: invalide part size item."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->EditPartSizeItem(a_nIndex, pPartSizeItem);

		return bRet;
	}

	CPartSizeFileClr^ CPartSizeFileMgrClr::GetPartSizeFile()
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFile: invalid pointer."));
			return nullptr;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();
		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFile: can't get part size file manager pointer."));
			return nullptr;
		}

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

		CPartSizeFileClr^ PartSizeFileClr = gcnew CPartSizeFileClr(pPartSizeFile);
		
		return PartSizeFileClr;
		
	}

	// particle analysis standard data
	void CPartSizeFileMgrClr::SetPartSizeFile(CPartSizeFileClr^ a_pPartSizeFile)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile: invalid pointer."));
			return;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();
		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile: can't get part size file manager pointer."));
			return;
		}
		ASSERT(a_pPartSizeFile);
		if (!a_pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile: can't get part size file manager pointer."));
			return;
		}
		CPartSizeFilePtr pPartSizeFile = a_pPartSizeFile->GetPartSizeFilePtr();
		ASSERT(pPartSizeFile);
		if (!pPartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSizeFile: can't get part size file manager pointer."));
			return;
		}
		pPartSizeFileMgr->SetPartSizeFile(pPartSizeFile);
		
	}

	// file pathname
	String^ CPartSizeFileMgrClr::GetPathName()
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: invalid pointer."));
			return nullptr;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();
		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: can't get part size file manager pointer."));
			return nullptr;
		}
		
		CString sPathName = pPartSizeFileMgr->GetPathName();
		String^ PathName = gcnew String(sPathName);

		return PathName;
	}
	void CPartSizeFileMgrClr::SetPathName(String^ a_strPathName)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: invalid pointer."));
			return;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();
		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: can't get part size file manager pointer."));
			return;
		}

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

		pPartSizeFileMgr->SetPathName(a_strPathName);
	}

	// modify flag
	bool CPartSizeFileMgrClr::IsModified()
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsModified: invalid pointer."));
			return false;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();
		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsModified: can't get part size file manager pointer."));
			return false;
		}

		bool bRet = pPartSizeFileMgr->IsModified();
		return bRet;

	}
	void CPartSizeFileMgrClr::SetModify(bool a_bModify)
	{
		if (m_LpPartSizeFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: invalid pointer."));
			return;
		}
		CPartSizeFileMgrPtr pPartSizeFileMgr = GetPartSizeFileMgrPtr();
		ASSERT(pPartSizeFileMgr);
		if (!pPartSizeFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: can't get part size file manager pointer."));
			return;
		}

		pPartSizeFileMgr->SetModify(a_bModify);

	}

}