OTS/OTSCPP/OTSClassifyEngine/ExpressionParseEngine/ParticleSTD.cpp

#pragma once
#include "stdafx.h"
#include "ParticleSTD.h"
#include "PartSTDRuleItem.h"
#include "ZeroElementRule.h"
#include "MaxEDSRule.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<PartSTDRuleItemPtr> ParticleSTD::GetSTDRuleItems()
{
	return m_stdRuleItems;
}



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_stdRuleItems)
	{	
		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_stdRuleItems.clear();
}

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

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

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

void ParticleSTD::setSTDList(PartSTDRuleItemList listSTDItem)
{
	m_stdRuleItems.insert(m_stdRuleItems.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<PartSTDRuleItem> 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_stdRuleItems.clear();
	for (unsigned int i = 0; i < xstds.size(); i++)
	{
		m_stdRuleItems.push_back(PartSTDRuleItemPtr(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());
	}
}

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