OTS/OTSCPP/OTSClassifyEngine/InclutionEngine/STDFileMgr.cpp

#include "stdafx.h"
#include "STDFileMgr.h"

#include "OTSFileSys.h"
//#include "OTSHelper.h"

namespace OTSClassifyEngine {

	const CString strInclutionPathName = ".\\Config\\SysData\\IncSysLib\\IncASTDData.db";

	// constructor
	CSTDFileMgr::CSTDFileMgr()
	{
		// initialization
		void Init();
	}

	// destructor
	CSTDFileMgr::~CSTDFileMgr()
	{
		// cleanup
		Cleanup();
	}

	// public
	BOOL CSTDFileMgr::CreateSTDFile()
	{
		// check file name
		m_strPathName.Trim();
		if (m_strPathName.IsEmpty())
		{
			// error, wrong file name
			LogErrorTrace(__FILE__, __LINE__, _T("Empty file path name"));
			ASSERT(FALSE);
			return FALSE;
		}

		// get database name
		CString sDatabaseName = GetPathName();

		if (OTSTools::COTSFileSys::Exists(sDatabaseName))
		{
			if (!Open(m_strPathName, FALSE))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Open STD file failed."));
				ASSERT(FALSE);
				return FALSE;
			}
		}
		else
		{
			if (!Create(m_strPathName))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Create X-ray file failed."));
				ASSERT(FALSE);
				return FALSE;
			}
		}

		return TRUE;
	}

	// Load/Save
	BOOL CSTDFileMgr::Load(BOOL a_bClear /*= TRUE*/)
	{
		CString a_strPathName=strInclutionPathName;
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		// clear all data if necessary
		if (a_bClear)
		{
			Init();
		}

		// check file pathname
		a_strPathName.Trim();
		if (a_strPathName.IsEmpty())
		{
			// file open dialog
			CFileDialog dlg(TRUE, STD_FILE_EXT, NULL, OFN_FILEMUSTEXIST, STD_FILE_FILTER);
			if (dlg.DoModal() != IDOK)
			{
				return FALSE;
			}

			// get file pathname
			a_strPathName = dlg.GetPathName();
		}

		// file pathname
		m_strPathName = a_strPathName;

		if (!CreateSTDFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		if (!GetListSTDItem())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Get STD Item list failed."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}
	void CSTDFileMgr::SetSTDItemList(CSTDItemsList& a_listSTDItem, BOOL a_bClear)
	{
		// clear holes list if necessary
		if (a_bClear)
		{
			m_listSTDItem.clear();
		}

		// copy the list
		for (auto pSTDItem : a_listSTDItem)
		{
			//CSTDItemPtr pSTDItemNew = CSTDItemPtr(new CSTDItem(*pSTDItem.get()));
			m_listSTDItem.push_back(pSTDItem);
		}
	}

	//add code by 2018-12-7
	CInclutionSTDDataPtr CSTDFileMgr::GetSysSTDLibByType(SYS_STD_TYPE a_nIdentifyType)
	{
		CSTDFileMgrPtr m_poSTDFileMgr = CSTDFileMgrPtr(new CSTDFileMgr());
		ASSERT(m_poSTDFileMgr);

		CInclutionSTDDataPtr a_pSTDlib;

		switch (a_nIdentifyType)
		{
		case SYS_STD_TYPE::GENERAL:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL1:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL2:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL3:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL4:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL5:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL6:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;
		case SYS_STD_TYPE::SPECIAL7:
			a_pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
			break;

		default:
			//error log

			break;
		}
		ASSERT(a_pSTDlib);
		if (!a_pSTDlib)
		{
			//error log
		}
		return a_pSTDlib;
	}
	
	CInclutionSTDDataPtr CSTDFileMgr::GenerateSTDLib(IDENTIFY_KIND a_nIdentifyKind)
	{
		CInclutionSTDDataPtr pPartSTDData = CInclutionSTDDataPtr(new CInclutionSTDData());

		if (a_nIdentifyKind < IDENTIFY_KIND::MIN || a_nIdentifyKind > IDENTIFY_KIND::MAX)
		{
			return nullptr;
		}
		if (m_listSTDItem.empty())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: system STD lib data is empty."));
			return nullptr;
		}

			CSTDItemsList listSTDItems;

			if (!((int)a_nIdentifyKind == (int)IDENTIFY_KIND::ALL))
			{
				for (auto Item : m_listSTDItem)
				{
					int nSTDId = Item->GetSTDId();
					int nStartId = (int)STD_START_ID + 100 * ((int)a_nIdentifyKind - 1) + 1;
					int nStopId = (int)STD_START_ID + 100 * (int)a_nIdentifyKind;
					if (nSTDId >= nStartId && nSTDId <= nStopId)
					{
						CSTDItemPtr newItem = CSTDItemPtr(new CSTDItem(*Item.get()));
						listSTDItems.push_back(newItem);
					}
				}
			}
			else
			{
				for (auto Item : m_listSTDItem)
				{
					CSTDItemPtr newItem = CSTDItemPtr(new CSTDItem(*Item.get()));
					listSTDItems.push_back(newItem);					
				}
			}

			pPartSTDData->SetSTDItemsList(listSTDItems, TRUE);
		

		// version
		CString strVersion = PART_STD_FILE_VERSION;
		pPartSTDData->SetFileVersion(strVersion);

		CString strName = _T("");

		switch ((int)a_nIdentifyKind)
		{
		case (int)IDENTIFY_KIND::ALL:
			strName = STD_FILE_SYS_ALL;
			break;
		case (int)IDENTIFY_KIND::SIMPLE_OXIDE:
			strName = STD_FILE_SYS_SIMPLE_OXIDE;
			break;
		case (int)IDENTIFY_KIND::COMPLEX_OXIDE:
			strName = STD_FILE_SYS_COMPLEX_OXIDE;
			break;
		case (int)IDENTIFY_KIND::SULFIDE:
			strName = STD_FILE_SYS_SULFIDE;
			break;
		case (int)IDENTIFY_KIND::NITRIDES:
			strName = STD_FILE_SYS_NITRIDES;
			break;
		}

		pPartSTDData->SetName(strName);

		//CElementsList m_listElements;
		//not used at this moment
		return pPartSTDData;
	}

	BOOL CSTDFileMgr::GetListSTDItem()
	{
		//get x-ray info list
		CSTDItemsList listInfo;
		listInfo.clear();

		if (!GetListSTDItem(listInfo))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetListSTDItem: get STD item list failed."));
			return FALSE;
		}

		if (listInfo.empty())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetListSTDItem: get STD item list failed."));
			return FALSE;
		}

		for (auto pInfo : listInfo)
		{
			//get x-ray data
			CSTDItemPtr pItem = CSTDItemPtr(new CSTDItem(*pInfo.get()));
			
			const long a_STDId = pInfo->GetSTDId();
			
			if (!GetSTDData(a_STDId, pItem))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetXrayList: get STD item data failed."));
				return FALSE;
			}

			//get element list

			/*long nElementSize = pInfo->GetElementRange();

			if (nElementSize == 0)
			{
				m_listSTDItem.push_back(pItem);
				continue;
			}*/

			/*CElementRangeList listElementRange;
			if (!GetElementRange(a_STDId, nElementSize, listElementRange))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetXrayList: get x-ray data failed."));
				return FALSE;
			}

			pItem->SetElementRangeList(listElementRange);*/
			
			m_listSTDItem.push_back(pItem);
		}
		return TRUE;
	}
	//Get XrayInfoList
	BOOL CSTDFileMgr::GetListSTDItem(CSTDItemsList& a_listSTDItem)
	{
		auto STDDataDB = GetSTDDataDB();
		if (!STDDataDB)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Failed to open STD data table"));
			ASSERT(FALSE);
			return FALSE;
		}

		a_listSTDItem = STDDataDB->GetSTDItemList(FALSE);

		return TRUE;
	}
	/*BOOL CSTDFileMgr::GetElementRange(const long a_nSTDId, const long a_nElementSize, CElementRangeList& a_listElementRange)
	{
		auto ElementRangeDB = GetElementRangeDB();
		if (!ElementRangeDB)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Failed to open element range table"));
			ASSERT(FALSE);
			return FALSE;
		}

		a_listElementRange.clear();
		a_listElementRange = ElementRangeDB->GetElementRangeListById(a_nSTDId, a_nElementSize);

		return TRUE;
	}*/
	BOOL CSTDFileMgr::GetSTDData(const long a_nSTDId, CSTDItemPtr a_pSTDItem)
	{
		ASSERT(a_pSTDItem);
		if (!a_pSTDItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Invalid STD data point."));
			return FALSE;
		}

		auto STDDataDB = GetSTDDataDB();
		if (!STDDataDB)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Failed to open STD data table"));
			ASSERT(FALSE);
			return FALSE;
		}

		a_pSTDItem = STDDataDB->GetSTDItemById(a_nSTDId);
	
		return TRUE;
	}
	CSTDDataDBPtr CSTDFileMgr::GetSTDDataDB()
	{
		if (!m_pSTDDataDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pSTDDataDB = std::make_shared<CSTDDataDB>(datastorePtr);
			}
		}

		ASSERT(m_pSTDDataDB);

		return m_pSTDDataDB;
	}
	/*CElementRangeDBPtr CSTDFileMgr::GetElementRangeDB()
	{
		if (!m_pElementRangeDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pElementRangeDB = std::make_shared<CElementRangeDB>(datastorePtr);
			}
		}

		ASSERT(m_pElementRangeDB);

		return m_pElementRangeDB;
	}*/
	
	// cleanup 
	void CSTDFileMgr::Cleanup()
	{
		// need to do nothing at the moment
		m_listSTDItem.clear();
	}
	// initialization
	void CSTDFileMgr::Init()
	{
		// initialization
		m_listSTDItem.clear();
	}
	// duplication 
	void CSTDFileMgr::Duplicate(const CSTDFileMgr& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		for (auto pSTDItem : a_oSource.m_listSTDItem)
		{
			CSTDItemPtr pSTDItemNew = CSTDItemPtr(new CSTDItem(*pSTDItem.get()));
			m_listSTDItem.push_back(pSTDItemNew);
		}
	}


}