OTS/OTSCPP/OTSClassifyEngine/ExpressionParseEngine/ParticleSTDDB.cpp

#include "stdafx.h"
#include "ParticleSTDDB.h"
#include "ParticleSTDTable.h"
#include "ParticleSTD.h"
#include <SQLiteDB.h>
#include <ExpressionParseEngine/STDGroupTable.h>

namespace OTSClassifyEngine
{
	namespace{
		
		std::string utf8ToGbk(const std::string& utf8Str) {
			// 第一步：UTF-8转UTF-16
			int wcsLen = MultiByteToWideChar(CP_UTF8, 0, utf8Str.c_str(), -1, nullptr, 0);
			wchar_t* wcsBuf = new wchar_t[wcsLen];
			MultiByteToWideChar(CP_UTF8, 0, utf8Str.c_str(), -1, wcsBuf, wcsLen);

			// 第二步：UTF-16转GBK
			int gbkLen = WideCharToMultiByte(CP_ACP, 0, wcsBuf, -1, nullptr, 0, nullptr, nullptr);
			char* gbkBuf = new char[gbkLen];
			WideCharToMultiByte(CP_ACP, 0, wcsBuf, -1, gbkBuf, gbkLen, nullptr, nullptr);

			std
				::string gbkStr(gbkBuf);
			delete[] wcsBuf;
			delete[] gbkBuf;
			return gbkStr;
		}
	
	}
	using namespace OTSSQLITE;
	CParticleSTDDB::CParticleSTDDB(CDBStoreBasePtr a_datastore)
	{
		m_tableInfo.reset(new CParticleSTDTable());
		myDB = CreateNewSQLiteDB(a_datastore, m_tableInfo);
	}

	CParticleSTDDB::~CParticleSTDDB()
	{
	}


	CDBTableBasePtr CParticleSTDDB::GetTableInfo()
	{
		

		return m_tableInfo;
	}

	BOOL CParticleSTDDB::Init(const BOOL a_bClean /*= FALSE*/)
	{
		return myDB->Init(a_bClean);
	}

	BOOL CParticleSTDDB::CreateTable(const BOOL a_bForce /*= FALSE*/)
	{
		return myDB->CreateTable(a_bForce);
	}

	BOOL CParticleSTDDB::DeleteTable()
	{
		return myDB->DeleteTable();
	}

	BOOL CParticleSTDDB::RemoveAllRows()
	{
		return myDB->RemoveAllRows();
	}

	BOOL CParticleSTDDB::IsDBExist()
	{
		return myDB->IsDBExist();
	}

	OTSSQLITE::CDBStoreBasePtr CParticleSTDDB::GetDatastore()
	{
		return myDB->GetDatastore();
	}

	OTSSQLITE::CDBQueryBasePtr CParticleSTDDB::GetTableQuery(LPCTSTR a_sOrderColumnName /*= nullptr*/)
	{
		return myDB->GetTableQuery(a_sOrderColumnName);
	}

	const int STDGroupsColCount = 4;
	const int ColCountComplement = 1;
	ParticleSTDPtr CParticleSTDDB::GetPartSTDLib(ParticleSTDPtr partStd,BOOL bForce/* = FALSE*/)
	{
		
		if (bForce)
		{
			partStd->PartSTDItemListClear();
		}
		

		CString cmdstr = "select * from ClassifySTD left join STDGroups on ClassifySTD.GroupId=STDGroups.id";
		auto query = myDB->GetCommandStringQuery(cmdstr);
		ASSERT(query);
		int cols = query->GetColCount();
		int defineCols =(int) CParticleSTDTable::ColumnID::MAX -(int) CParticleSTDTable::ColumnID::MIN+STDGroupsColCount+ ColCountComplement;
		if (cols != defineCols)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("std db version is not match!"));
			return NULL;
		}


		auto partstdlist= ReadParticleSTDList(query);
		partStd->setSTDList(partstdlist);

		
		return partStd;
	}
	

	PartSTDRuleItemList CParticleSTDDB::ReadParticleSTDList(CDBQueryBasePtr a_query)
	{
		PartSTDRuleItemList listSTDItem;
		
		int nRowId = 0;
		int nWrongItems = 0;
		while (!a_query->IsEOF())
		{
			auto itm = PartSTDRuleItemPtr(new PartSTDRuleItem());
			if (!ReadParticleSTDItem(a_query,itm))	//current x-ray point		
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Read xray point failed"));
				nWrongItems++;
				break;
			}

			listSTDItem.push_back(itm);

			a_query->NextRow();
			nRowId++;
		}

		return listSTDItem;
	}

	BOOL CParticleSTDDB::ReadParticleSTDItem(CDBQueryBasePtr a_query, PartSTDRuleItemPtr stdItem)
	{
		int nCol;
	
		
		int nIncAIdNow;
		nCol = (int)CParticleSTDTable::ColumnID::N_STDId - (int)CParticleSTDTable::ColumnID::MIN;
		nIncAIdNow = a_query->GetColIntValue(nCol, -1);
		stdItem->SetID(nIncAIdNow);

		CString sIncAName;
		nCol = (int)CParticleSTDTable::ColumnID::S_StrName - (int)CParticleSTDTable::ColumnID::MIN;
		sIncAName = a_query->GetColStringValue(nCol, _T(""));
		std::string gbkName = utf8ToGbk(sIncAName.GetString());	
		stdItem->SetName(gbkName);

		CString sColor;
		nCol = (int)CParticleSTDTable::ColumnID::S_COLOR - (int)CParticleSTDTable::ColumnID::MIN;
		sColor = a_query->GetColStringValue(nCol, _T(""));
		if (sColor.Left(1) != "#") sColor = "#" + sColor;
		stdItem->SetColor(sColor.GetString());

		CString sKeyElementList;
		nCol = (int)CParticleSTDTable::ColumnID::S_KeyElementList - (int)CParticleSTDTable::ColumnID::MIN;
		sKeyElementList = a_query->GetColStringValue(nCol, _T(""));
		std::vector < std::string> keyeleStrlist;
		xmls::SplitString(sKeyElementList.GetBuffer(), keyeleStrlist, ",");
		CElementsList elelist;
		for (auto s : keyeleStrlist)
		{
			CElementPtr ele = CElementPtr(new CElement(s.c_str()));
			elelist.push_back(ele);
		}
		stdItem->SetKeyElementList(elelist);

		CString sSubElementList;
		nCol = (int)CParticleSTDTable::ColumnID::S_SubElementList - (int)CParticleSTDTable::ColumnID::MIN;
		sSubElementList = a_query->GetColStringValue(nCol, _T(""));
		std::vector < std::string> SubeleStrlist;
		xmls::SplitString(sSubElementList.GetBuffer(), SubeleStrlist, ",");
		elelist.clear();
		for (auto s : SubeleStrlist)
		{
			CElementPtr ele = CElementPtr(new CElement(s.c_str()));
			elelist.push_back(ele);
		}
		stdItem->SetSubElementList(elelist);


		CString sUsingImgPropertyList;
		nCol = (int)CParticleSTDTable::ColumnID::S_UsingImgPropertyList - (int)CParticleSTDTable::ColumnID::MIN;
		sUsingImgPropertyList = a_query->GetColStringValue(nCol, _T(""));
		std::vector < std::string> UsingImgPropertyeleStrlist;
		xmls::SplitString(sUsingImgPropertyList.GetBuffer(), UsingImgPropertyeleStrlist, ",");
		
		std::vector<std::string> val;
		for (auto s : UsingImgPropertyeleStrlist)
		{
			val.push_back(s);
		}
		stdItem->SetUsingImgPropertyNameList(val);



		CString sUsingOtherPropertyList;
		nCol = (int)CParticleSTDTable::ColumnID::S_UsingOtherPropertyList - (int)CParticleSTDTable::ColumnID::MIN;
		sUsingOtherPropertyList = a_query->GetColStringValue(nCol, _T(""));

		std::vector < std::string> UsingOtherPropertyStrlist;
		xmls::SplitString(sUsingOtherPropertyList.GetBuffer(), UsingOtherPropertyStrlist, ",");
		val.clear();
		for (auto s : UsingOtherPropertyStrlist)
		{
			val.push_back(s);
		}
		stdItem->SetUsingOtherpropertyList(val);



		CString sExpression;
		nCol = (int)CParticleSTDTable::ColumnID::S_Expression - (int)CParticleSTDTable::ColumnID::MIN;
		sExpression = a_query->GetColStringValue(nCol, _T(""));
		stdItem->SetExpressionStr(sExpression.GetString());

		std::string dHardness;
		nCol = (int)CParticleSTDTable::ColumnID::S_Hardness - (int)CParticleSTDTable::ColumnID::MIN;
		dHardness = a_query->GetColStringValue(nCol, _T(""));
		stdItem->SetHardness(dHardness);

		std::string dDensity;
		nCol = (int)CParticleSTDTable::ColumnID::S_Density - (int)CParticleSTDTable::ColumnID::MIN;
		dDensity = a_query->GetColStringValue(nCol, _T(""));
		stdItem->SetDensity(dDensity);

		std::string dElectrical_conductivity;
		nCol = (int)CParticleSTDTable::ColumnID::S_Electrical_conductivity - (int)CParticleSTDTable::ColumnID::MIN;
		dElectrical_conductivity = a_query->GetColStringValue(nCol, _T(""));
		stdItem->SetElectrical_conductivity(dElectrical_conductivity);

		int nBSE;
		nCol = (int)CParticleSTDTable::ColumnID::N_BSE - (int)CParticleSTDTable::ColumnID::MIN;
		nBSE = a_query->GetColIntValue(nCol, -1);
		stdItem->SetBSE(nBSE);

		CString sFormula;
		nCol = (int)CParticleSTDTable::ColumnID::S_Formula - (int)CParticleSTDTable::ColumnID::MIN;
		sFormula = a_query->GetColStringValue(nCol, _T(""));
		stdItem->SetFormula(sFormula.GetString());

		CString sElement;
		nCol = (int)CParticleSTDTable::ColumnID::S_Element - (int)CParticleSTDTable::ColumnID::MIN;
		sElement = a_query->GetColStringValue(nCol, _T(""));
		stdItem->SetElement(sElement.GetString());


		int isElementanalysis;
		nCol = (int)CParticleSTDTable::ColumnID::B_IsElementAnalysis - (int)CParticleSTDTable::ColumnID::MIN;
		isElementanalysis = a_query->GetColIntValue(nCol, 1);
		stdItem->SetIsElementAnalysis(isElementanalysis==1);

		int grpid;
		nCol = (int)CParticleSTDTable::ColumnID::N_GroupId- (int)CParticleSTDTable::ColumnID::MIN;
		grpid = a_query->GetColIntValue(nCol, -1);
		stdItem->SetGrpID(grpid);

		CString grpName;
		nCol = (int)CParticleSTDTable::ColumnID::N_GroupId - (int)CParticleSTDTable::ColumnID::MIN+(int)CSTDGroupTable::ColumnID::S_NAME- (int)CSTDGroupTable::ColumnID::MIN+1;
		grpName = a_query->GetColStringValue(nCol, _T(""));
		std::string gbkGrpName = utf8ToGbk(grpName.GetString());	
		stdItem->SetGrpName(gbkGrpName);

		CString grpColor;
		nCol = (int)CParticleSTDTable::ColumnID::N_GroupId - (int)CParticleSTDTable::ColumnID::MIN + (int)CSTDGroupTable::ColumnID::S_COLOR - (int)CSTDGroupTable::ColumnID::MIN+1;
		grpColor = a_query->GetColStringValue(nCol, _T(""));
		if (grpColor.Left(1) != "#") sColor = "#" + grpColor;
		stdItem->SetGrpColor(grpColor.GetString());

		return TRUE;
	}
	
}