OTS/OTSCPP/OTSClassifyEngine/ParticleEngine/ParticleSTD.cpp

#pragma once
#include "stdafx.h"
#include "ParticleSTD.h"
#include "XMLSerialization.h"
#include "OTSFileSys.h"
#include "Element.h"
using namespace OTSTools;
using namespace OTSDATA;
using namespace xmls;
const CString strPathName = ".\\Config\\SysData\\OTSParticleSTD.xml" ;

std::vector<PartSTDItemPtr> ParticleSTD::GetSTDItems()
{
	return m_stdItems;
}



ZeroElementRuleList ParticleSTD::GetZeroRules()
{	
   return m_zeroRules;	
}

MaxEDSRuleList ParticleSTD::GetMaxEDSRules()
{
	return m_MaxRules;
}

bool ParticleSTD::LoadItemsFromFile()
{
	tinyxml2::XMLDocument doc;
	if (COTSFileSys::Exists(strPathName))
	{
		doc.LoadFile(strPathName);//ÔØÈëxmlÎļþ
	}
	

	tinyxml2::XMLElement *rootNode;
	rootNode = doc.FirstChildElement(RootClassName);
	Serialize(false, &doc, rootNode);
	
	for (auto itm : m_stdItems)
	{	
		std::string exp = itm->GetExpressionStr();

			for (auto s : itm->GetUsingConstants())
			{
				
				xmls::ReplaceAll(exp, s, std::to_string(m_mapConstants[s]));
			}
			itm->SetExpressionStr(exp);
	}

	return true;
}

void ParticleSTD::PartSTDItemListClear()
{
	m_stdItems.clear();
}

void ParticleSTD::ZeroElementRuleListClear()
{
	m_zeroRules.clear();
}

void ParticleSTD::MaxEDSRuleListClear()
{
	m_MaxRules.clear();
}

void ParticleSTD::ConstantsMapClear()
{
	m_mapConstants.clear();
}

void ParticleSTD::setSTDList(PartSTDItemList listSTDItem)
{
	m_stdItems.insert(m_stdItems.end(), listSTDItem.begin(), listSTDItem.end());
}

void ParticleSTD::setZeroElementRuleList(ZeroElementRuleList listZeroElementRuleItem)
{
	m_zeroRules.insert(m_zeroRules.end(), listZeroElementRuleItem.begin(), listZeroElementRuleItem.end());
}

void ParticleSTD::setMaxEDSRuleList(MaxEDSRuleList listMaxEDSRuleItem)
{
	m_MaxRules.insert(m_MaxRules.end(), listMaxEDSRuleItem.begin(), listMaxEDSRuleItem.end());
}

void ParticleSTD::setConstantsMap(map<std::string, double> listConstantsItem)
{
	map<string, double>::iterator it;
	for (it = listConstantsItem.begin(); it != listConstantsItem.end(); it++)
	{
		m_mapConstants[it->first]=it->second;
	}
}

std::map<std::string,double>& ParticleSTD::GetMapConstants()
{
	return m_mapConstants;
}
void ParticleSTD::Serialize(bool isStoring, tinyxml2::XMLDocument *classDoc, tinyxml2::XMLElement *rootNode)
{
	xmls::Slo slo;
	xmls::Collection<PartSTDItem> xstds;
	xmls::Collection<MaxEDSRule> xMaxEDSRules;
	xmls::Collection<ZeroElementRule> xZeroRules;
	xmls::Slo xConstants;
	xmls::xString xConstantsStr;
	xConstants.Register("value", &xConstantsStr);

	slo.Register("Constants", &xConstants);
	slo.Register("MaxEDSRules", &xMaxEDSRules);
	slo.Register("ZeroElementRules", &xZeroRules);
	slo.Register("STDList", &xstds);
	
	
	if (isStoring)
	{

		slo.Serialize(true, classDoc, rootNode);
	}
	else
	{
		slo.Serialize(false, classDoc, rootNode);

	}
	m_stdItems.clear();
	for (unsigned int i = 0; i < xstds.size(); i++)
	{
		m_stdItems.push_back(PartSTDItemPtr(xstds.getItem(i)));
	}
	for (unsigned int i = 0; i < xMaxEDSRules.size(); i++)
	{
		m_MaxRules.push_back(MaxEDSRulePtr(xMaxEDSRules.getItem(i)));
	}
	for (unsigned int i = 0; i < xZeroRules.size(); i++)
	{
		m_zeroRules.push_back(ZeroElementRulePtr(xZeroRules.getItem(i)));
	}
	std::string constantsstr = xConstantsStr.value();
	std::vector<std::string> strs;
	xmls::SplitString(constantsstr, strs, ",");
	for (std::string s : strs)
	{
		std::vector<std::string> oneExp;
		xmls::SplitString(s, oneExp, "=");
		m_mapConstants[oneExp[0]] =std::atof( oneExp[1].c_str());
	}
}

PartSTDItemPtr ParticleSTD::GetSTDItemById(int id)
{
	for (auto itm : m_stdItems)
	{
		if (itm->GetID() == id)
		{
			return itm;
		}
	}
	return nullptr;
}

std::map<std::string, OTSDATA::CElementPtr>& PartSTDItem::GetMapElements()
{
	if (m_mapEleItems.size() == 0)
	{
		for (auto ele : m_KeyelementList)
		{
			m_mapEleItems[ele->GetName().GetBuffer()] = ele;
		}
	}
	
	return m_mapEleItems;
}

void PartSTDItem::Serialize(bool isStoring, tinyxml2::XMLDocument *classDoc, tinyxml2::XMLElement *rootNode)
{
	// name
	xmls::xString xstrName;
	// color
	xmls::xString xsColor;//COLORREF, C# can't access

	xmls::xInt xnSTDId;
	xmls::xString xKeyElementListStr;
	xmls::xString xSubElementListStr;
	
	xmls::xString xUsingConstants;
	xmls::xString xImgPropertyListStr;
	xmls::xString xOtherPropertyListStr;
	xmls::xString xExpstr;
	//xmls::Collection< CElementRange> xElementRanges;
	xmls::xString xHardness;
	xmls::xString xDensity;
	xmls::xString xElectrical_conductivity;

	xmls::Slo slo;
	slo.Register("StrName", &xstrName);
	slo.Register("Color", &xsColor);

	slo.Register("STDId", &xnSTDId);

	slo.Register("KeyElementList", &xKeyElementListStr);
	slo.Register("SubElementList", &xSubElementListStr);
	slo.Register("UsingConstants", &xUsingConstants);
	slo.Register("UsingImgPropertyList", &xImgPropertyListStr);
	slo.Register("UsingOtherPropertyList", &xOtherPropertyListStr);
	slo.Register("Expression", &xExpstr);
	slo.Register("Hardness", &xHardness);
	slo.Register("Density", &xDensity);
	slo.Register("Electrical_conductivity", &xElectrical_conductivity);
	if (isStoring)
	{
		xstrName = GetName();
		xsColor = GetColor();
		xHardness = m_Hardness;
		xDensity = m_Density;
		xElectrical_conductivity = m_Electrical_conductivity;
		xnSTDId = GetID();

		CString s = "";
		for (auto poElement : m_KeyelementList)
		{
			s  += poElement->GetName()+",";
		}
		s = s.TrimRight(",");
		xKeyElementListStr = s;

		 s = "";
		for (auto poElement : m_SubelementList)
		{
			s += poElement->GetName() + ",";
		}
		s = s.TrimRight(",");
		xSubElementListStr = s;

		for (auto pName : m_ImgPropertyList)
		{
			s += pName.c_str() ;
			s += ",";
		}
		s = s.TrimRight(",");
		xImgPropertyListStr = s;

		for (auto pName : m_OtherpropertyList)
		{
			s += pName.c_str();
			s += ",";
		}
		s = s.TrimRight(",");
		xOtherPropertyListStr = s;

		slo.Serialize(true, classDoc, rootNode);
	}
	else
	{
		slo.Serialize(false, classDoc, rootNode);

		SetName(xstrName.value().c_str());
		SetColor(xsColor.value().c_str());
		SetExpressionStr(xExpstr.value());
		 m_Hardness=xHardness.value() ;
		 m_Density= xDensity.value();
		 m_Electrical_conductivity=xElectrical_conductivity.value();
		SetID(xnSTDId.value());
		std::vector<string> eles; 

		std::string elements = xKeyElementListStr.c_str();
		xmls::SplitString(elements, eles, ",");
		for (int i = 0; i < eles.size(); ++i)
		{
			CString ss = eles[i].c_str();
			m_KeyelementList.push_back(CElementPtr(new CElement(ss)));
		}

		 elements = xSubElementListStr.c_str();
		 eles.clear();
		xmls::SplitString(elements, eles, ",");
		for (int i = 0; i < eles.size(); ++i)
		{
			CString ss = eles[i].c_str();
			m_SubelementList.push_back(CElementPtr(new CElement(ss)));
		}


		std::vector<string> pNames;
		std::string propertynames = xImgPropertyListStr.c_str();
		xmls::SplitString(propertynames, pNames, ",");
		for (int i = 0; i < pNames.size(); ++i)
		{
			std::string ss = pNames[i];
			m_ImgPropertyList.push_back(ss);
		}
		std::vector<string> pOthers;
		std::string otherPropertynames = xOtherPropertyListStr.c_str();
		xmls::SplitString(otherPropertynames, pOthers, ",");
		for (int i = 0; i < pOthers.size(); ++i)
		{
			std::string ss = pOthers[i];
			m_OtherpropertyList.push_back(ss);
		}
		for (auto ele : m_KeyelementList)
		{
			m_mapEleItems[ele->GetName().GetBuffer()] = ele;
		}
		xmls::SplitString(xUsingConstants.value(), m_usingConstants ,",");

	}

}

void ZeroElementRule::Serialize(bool isStoring, tinyxml2::XMLDocument *classDoc, tinyxml2::XMLElement *rootNode)
{
	xmls::xString xUsingElementListStr;
	xmls::xString xUsingConstants;
	xmls::xString xImgPropertyListStr;
	xmls::xString xOtherPropertyListStr;
	xmls::xString xExpstr;
	xmls::xString xZeroEleName;

	xmls::Slo slo;

	slo.Register("ZeroElement", &xZeroEleName);
	slo.Register("UsingElementList", &xUsingElementListStr);
	slo.Register("UsingConstants", &xUsingConstants);
	slo.Register("UsingImgPropertyList", &xImgPropertyListStr);
	slo.Register("UsingOtherPropertyList", &xOtherPropertyListStr);
	slo.Register("Expression", &xExpstr);

	if (isStoring)
	{
		xZeroEleName= m_ZeroElementName;

		CString s = "";
		for (auto poElement : m_UsingelementList)
		{
			s += poElement->GetName() + ",";
		}
		s = s.TrimRight(",");
		xUsingElementListStr = s;
		s = "";
		
		
		for (auto pName : m_ImgPropertyList)
		{
			s += pName.c_str();
			s += ",";
		}

		s = s.TrimRight(",");
		xImgPropertyListStr = s;
		s = "";
		for (auto pName : m_OtherpropertyList)
		{
			s += pName.c_str();
			s += ",";
		}
		s = s.TrimRight(",");
		xOtherPropertyListStr = s;

		slo.Serialize(true, classDoc, rootNode);
	}
	else
	{
		slo.Serialize(false, classDoc, rootNode);


		SetExpressionStr(xExpstr.value());
		m_ZeroElementName = xZeroEleName.value();
		std::vector<string> eles;

		std::string elements = xUsingElementListStr.c_str();
		xmls::SplitString(elements, eles, ",");
		for (int i = 0; i < eles.size(); ++i)
		{
			CString ss = eles[i].c_str();
			m_UsingelementList.push_back(CElementPtr(new CElement(ss)));
		}
			   
		std::string propertynames = xImgPropertyListStr.c_str();
		xmls::SplitString(propertynames, m_ImgPropertyList, ",");
		
		std::string otherPropertynames = xOtherPropertyListStr.c_str();
		xmls::SplitString(otherPropertynames, m_OtherpropertyList, ",");
		

		xmls::SplitString(xUsingConstants.value(), m_usingConstants, ",");
	}
}

void MaxEDSRule::Serialize(bool isStoring, tinyxml2::XMLDocument *classDoc, tinyxml2::XMLElement *rootNode)
{
	xmls::xString xElementListStr;
	xmls::xString xUsingConstants;
	xmls::xString xImgPropertyListStr;
	xmls::xString xOtherPropertyListStr;
	xmls::xString xExpstr;
	xmls::xDouble xEdsTime;

	xmls::Slo slo;

	slo.Register("EDSTime", &xEdsTime);
	slo.Register("UsingElementList", &xElementListStr);
	slo.Register("UsingConstants", &xUsingConstants);
	slo.Register("UsingImgPropertyList", &xImgPropertyListStr);
	slo.Register("UsingOtherPropertyList", &xOtherPropertyListStr);
	slo.Register("Expression", &xExpstr);

	if (isStoring)
	{
		xEdsTime = m_MaxEDSTime;
		CString s = "";
		for (auto poElement : m_elementList)
		{
			s += poElement->GetName() + ",";
		}
		s = s.TrimRight(",");
		xElementListStr = s;
		for (auto pName : m_ImgPropertyList)
		{
			s += pName.c_str();
			s += ",";
		}
		s = s.TrimRight(",");
		xImgPropertyListStr = s;

		for (auto pName : m_OtherpropertyList)
		{
			s += pName.c_str();
			s += ",";
		}
		s = s.TrimRight(",");
		xOtherPropertyListStr = s;

		slo.Serialize(true, classDoc, rootNode);
	}
	else
	{
		slo.Serialize(false, classDoc, rootNode);


		m_expressionStr = xExpstr.value();
		m_MaxEDSTime = xEdsTime.value();
		std::vector<string> eles;
		std::string elements = xElementListStr.c_str();
		xmls::SplitString(elements, eles, ",");
		for (int i = 0; i < eles.size(); ++i)
		{
			CString ss = eles[i].c_str();
			m_elementList.push_back(CElementPtr(new CElement(ss)));
		}
		std::string propertynames = xImgPropertyListStr.value();
		xmls::SplitString(propertynames, m_ImgPropertyList, ",");

		std::string otherPropertynames = xOtherPropertyListStr.value();
		xmls::SplitString(otherPropertynames, m_OtherpropertyList, ",");


		xmls::SplitString(xUsingConstants.value(), m_usingConstants, ",");
	}
}