OTS/OTSCPP/OTSClassifyEngine/CurveCompareEngine/OTSSTDLibFileMgr.cpp

#include "stdafx.h"
#include "OTSSTDLibFileMgr.h"
#include "OTSFileSys.h"
using namespace OTSTools;
namespace OTSClassifyEngine
{
	// project file extension
	const CString ORETYPE_FILE_EXT = _T("db");
	const CString ORETYPE_FILE_FILTER = _T("Particle Type Files (*.db)|*.db|All Files (*.*)|*.*||");
	const CString SysSTDLibFilePath = ".\\Config\\SysData\\";
	// constructor
	CSTDLibFileMgr::CSTDLibFileMgr(std::string fileName)
	{
		m_strPathName = SysSTDLibFilePath+fileName.c_str();

		Init();
	}

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

	BOOL CSTDLibFileMgr::CreateSTDLibFile()
	{
		// 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;
		}
		if (COTSFileSys::Exists(m_strPathName))
		{
			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;
	}

	CSTDLibPtr CSTDLibFileMgr::GetSTDLib(BOOL bForce/* = FALSE*/)
	{
		//GetSTDLibDB();
		return m_pSTDLibDB->GetSTDLib(bForce);
	}

	// Load/Save
	BOOL CSTDLibFileMgr::Load(CSTDLibPtr& lib, BOOL bClear /*= TRUE*/)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
;
		// program manager param file exists?
		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."+ m_strPathName));
			return FALSE;
		}
		
		
		
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetSTDLibDB();
		lib = m_pSTDLibDB->GetSTDLib(bClear);
		return TRUE;
	}

	BOOL CSTDLibFileMgr::LoadPartSTD(ParticleSTDPtr lib, BOOL bClear /*= TRUE*/)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."+ m_strPathName));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetParticleSTDDB();

		lib = m_pParticleSTDDB->GetPartSTDLib(lib,bClear);

		return TRUE;
	}

	BOOL CSTDLibFileMgr::LoadZeroElementRulesData(ParticleSTDPtr lib, BOOL bClear /*= TRUE*/)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetZeroElementRulesDataDB();

		auto rules= m_pZeroElementRulesDataDB->GetZeroElementRulesLib(bClear);
		lib->setZeroElementRuleList(rules);

		return TRUE;
	}

	BOOL CSTDLibFileMgr::LoadMaxEDSRulesData(ParticleSTDPtr lib, BOOL bClear /*= TRUE*/)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		m_pMaxEDSRulesDataDB=GetMaxEDSRulesDataDB();

	auto 	maxedsrls = m_pMaxEDSRulesDataDB->GetMaxEDSRulesLib(bClear);
	lib->setMaxEDSRuleList(maxedsrls);

		return TRUE;
	}

	std::string CSTDLibFileMgr::LoadConstantsData( BOOL bClear /*= TRUE*/)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetConstantsDataDb();

		return  m_pConstantsDataDb->GetConstantsLib(bClear);

		//return TRUE;
	}

	CSTDLibDBPtr CSTDLibFileMgr::GetSTDLibDB()
	{
		if (!m_pSTDLibDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pSTDLibDB = std::make_shared<CSTDLibDB>(datastorePtr);
			}
		}

		ASSERT(m_pSTDLibDB);

		return m_pSTDLibDB;
	}

	CParticleSTDDBPtr CSTDLibFileMgr::GetParticleSTDDB()
	{
		if (!m_pParticleSTDDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pParticleSTDDB = std::make_shared<CParticleSTDDB>(datastorePtr);
			}
		}

		ASSERT(m_pParticleSTDDB);

		return m_pParticleSTDDB;
	}

	OTSClassifyEngine::CConstantsDataDbPtr CSTDLibFileMgr::GetConstantsDataDb()
	{
		if (!m_pConstantsDataDb)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pConstantsDataDb = std::make_shared<CConstantsDataDb>(datastorePtr);
			}
		}

		ASSERT(m_pConstantsDataDb);

		return m_pConstantsDataDb;
	}

	OTSClassifyEngine::CMaxEDSRulesDataDBPtr CSTDLibFileMgr::GetMaxEDSRulesDataDB()
	{
		if (!m_pMaxEDSRulesDataDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pMaxEDSRulesDataDB = std::make_shared<CMaxEDSRulesDataDB>(datastorePtr);
			}
		}

		ASSERT(m_pMaxEDSRulesDataDB);

		return m_pMaxEDSRulesDataDB;
	}

	OTSClassifyEngine::CZeroElementRulesDataDBPtr CSTDLibFileMgr::GetZeroElementRulesDataDB()
	{
		if (!m_pZeroElementRulesDataDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pZeroElementRulesDataDB = std::make_shared<CZeroElementRulesDataDB>(datastorePtr);
			}
		}

		ASSERT(m_pZeroElementRulesDataDB);

		return m_pZeroElementRulesDataDB;
	}

	void CSTDLibFileMgr::Init()
	{
	}

	void CSTDLibFileMgr::Cleanup()
	{
	}
}