#pragma execution_character_set("utf-8")

#include "DataPack.h"
#include <QDateTime>
#include "M_EntityModelDAO.h"
#include "M_EntityTableDAO.h"
#include "M_FolderDAO.h"
#include "DataManager.h"
#include "DataClass.h"
#include "global.h"
#include "DataModelData.h"
#include "SceneInfo.h"
#include "M_SceneInfoDAO.h"
#include < regex >
//数据模块

DataPack::DataPack()
{
	_baseType = g_TYPE_DATAPACK;
}

DataPack::~DataPack()
{

}

// void static backupDAOData(DBPlatformSpace::M_FolderDAO& src, DBPlatformSpace::M_FolderDAO& dst)
// {

// }

// void static restoreData(DBPlatformSpace::M_FolderDAO& src, DataPack& dst)
// {
// 	//主要恢复界面属性值和updateTime值
// }


/*移去所有children*/
void DataPack::removeChildinDPMap()
{
	DataManager& mgr = GetDataRoot();

	QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
	while (it != _childrenMap.end())
	{
		if ((int)(*it)->_baseType == g_TYPE_DATAPACK)
		{
			mgr.deleteInDataMap(DataManager::DataType::dataPack, (*it)->_id);
			qobject_cast<DataPack*>(*it)->removeChildinDPMap();
			it++;
		}
		else if ((int)(*it)->_baseType == g_TYPE_DATACLASS)
		{
			mgr.deleteInDataMap(DataManager::DataType::dataClass, (*it)->_id);
			qobject_cast<DataClass*>(*it)->removeChildinDPMap();
			it++;
		}
	}
}

void DataPack::saveToDao()
{
	using namespace  DBPlatformSpace;
	M_FolderDAO* pDao = dynamic_cast<M_FolderDAO*>(_pDBDAO);

	if (pDao == nullptr)
	{
		pDao = new M_FolderDAO();
		_pDBDAO = pDao;
	}

	//	pDao->_ID = getID();
	pDao->_name = CommonHelper::qstringToStdString(getName());   //数据模型标识
	pDao->_displayName = CommonHelper::qstringToStdString(_strDisplayName);
	pDao->_folderType = _folderType;
	pDao->_description = CommonHelper::qstringToStdString(_strDescription);
	pDao->_isGenerateDAO = _bIsGenerateTable;

}

/*保存本身数据*/
bool DataPack::saveSelf()
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	/*将这条项目数据写入数据库*/
	M_FolderDAO* pDao = dynamic_cast<M_FolderDAO*>(_pDBDAO);
	/*备份DAO数据*/
	M_FolderDAO oldDaoData;
	if (pDao == nullptr)
	{
		pDao = new M_FolderDAO();
		_pDBDAO = pDao;
	}
	else
	{
		// backupDAOData(*pDao, oldDaoData);
	}

	saveToDao();

	rm = pDao->save();
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.save  success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.save  failed");
		LOG(ERROR) << rm.rMsg;
		// restoreData(oldDaoData, *this);
		return false;
	}
}

/*增加下层数据*/
bool DataPack::addChild(DPData* pNewData)
{
	//判断是增加数据类还是子模块
	using namespace DBPlatformSpace;
	ResultMsg rm;

	if ((int)pNewData->_baseType == g_TYPE_DATAPACK)
	{
		M_FolderDAO* pPackDAO = dynamic_cast<M_FolderDAO*>(_pDBDAO);
		pNewData->saveToDao();
		M_FolderDAO* pNewDAO = dynamic_cast<M_FolderDAO*>(pNewData->_pDBDAO);

		rm = pPackDAO->addM_SubFolderDAO(pNewDAO);
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addM_SubFolderDAO  success");
			pNewData->_id = pNewDAO->_ID;
			pNewData->_parent = this;
			_childrenMap.insert(pNewData->_id, pNewData);
			return true;
		}
		else
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addM_SubFolderDAO  failed");
			LOG(ERROR) << rm.rMsg;
			return false;
		}
	}
	else /*if (pNewData->_baseType == g_TYPE_DATACLASS)*/
	{
	//	qobject_cast<DataClass*>(pNewData)->reName();
		pNewData->saveToDao();
		M_FolderDAO* pPackDAO = dynamic_cast<M_FolderDAO*>(_pDBDAO);
		M_EntityTableDAO* pNewClassDAO = dynamic_cast<M_EntityTableDAO*>(pNewData->_pDBDAO);
		QString msg = "DataPack::addClass:newClass:" + QString::number(pNewClassDAO->_ID) + "--" + CommonHelper::stringToQstring(pNewClassDAO->_name);
		LOG(INFO) << CommonHelper::qstringToString(msg);
		rm = pPackDAO->addM_EntityTableDAO(pNewClassDAO);
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.addM_EntityTableDAO  success");
			DataClass* pNewTable = qobject_cast<DataClass*>(pNewData);
			pNewTable->_id = pNewClassDAO->_ID;
			//version相关从数据库来 innerName从数据库来
			pNewTable->_wCreateVersion = pNewClassDAO->_addVersion;
			pNewTable->_wDeleteVersion = pNewClassDAO->_delVersion;
			pNewTable->_strInternalName = CommonHelper::stringToQstring(pNewClassDAO->_innerName);
			pNewTable->_parent = this;
			//dao中的是否删除 要不要保存？
			_childrenMap.insert(pNewData->_id, pNewData);
			QString msg_ = "DataPack::addend:" + QString::number(pNewClassDAO->_ID) + "--" + CommonHelper::stringToQstring(pNewClassDAO->_name);
			LOG(INFO) << CommonHelper::qstringToString(msg_);
			return true;
		}
		else
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.addM_EntityTableDAO  failed");
			LOG(ERROR) << rm.rMsg;
			return false;
		}
	}

}


/*删除一条child数据*/
bool DataPack::deleteChild(unsigned int id)
{
	if (_childrenMap.remove(id))
	{
		return true;
	}
	else
	{
		return false;
	}
}

/*删除本对象*/
bool DataPack::deleteSelf()
{
	if (_pDBDAO)
	{
		DBPlatformSpace::ResultMsg rm = _pDBDAO->delself();
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.delself  success");
			if (_parent)
			{
				_parent->deleteChild(_id);
				removeChildinDPMap();
				return true;
			}
			else
			{
				//_parent为空
				return false;
			}
		}
		else
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.delself  failed");
			LOG(ERROR) << rm.rMsg;
			//数据库删除失败
			return false;
		}
	}
	else
	{
		//_pDBDAO为空
		return false;
	}

}

bool DataPack::deleteSelf(QString& result)
{
	if (_pDBDAO)
	{
		using namespace DBPlatformSpace;
		ResultMsg rm;
		std::string resultStr;
		M_FolderDAO* pFolder = dynamic_cast<M_FolderDAO*>(_pDBDAO);
		rm = pFolder->delself(resultStr);
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.delself success ");
			result = CommonHelper::stringToQstring(resultStr);
			DataClass::resolveDeleteResult(result);
			//删除child
			_parent->deleteChild(_id);
			removeChildinDPMap();
			return true;
		}
		else
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.delself failed ");
			LOG(ERROR) << rm.rMsg;
			//数据库删除失败
			return false;
		}

	}
	else
	{
		return false;
	}

}

/*从数据库加载一条数据到当前对象*/
void DataPack::loadData(DBPlatformSpace::DAO* pDao)
{
	_pDBDAO = pDao;
	//将DAO数据存入DataModelData对象
	DBPlatformSpace::M_FolderDAO* pDAOData = dynamic_cast<DBPlatformSpace::M_FolderDAO*>(_pDBDAO);
	setID(pDAOData->_ID);
	setName(CommonHelper::stringToQstring(pDAOData->_name)); //数据模型标识
	_folderType = pDAOData->_folderType;
	_strDescription = CommonHelper::stringToQstring(pDAOData->_description);
	_strDisplayName = CommonHelper::stringToQstring(pDAOData->_displayName);
	_bIsGenerateTable = pDAOData->_isGenerateDAO;
	_wCreateVersion = pDAOData->_addVersion;
}

/*获取所有下层数据*/
void DataPack::getAllChildren(DPData* pManager)
{
	if (!_initSubPack || !_initDataClass)
	{
		//获取子模块
		getSubPack(pManager);
		//获取下层数据类
		getDataClassAndAttribute(pManager);
	}
	// 	else 
	// 	{
	// 		this->toJson(jsonObj, true);
	// 	}
}

void DataPack::toJson(json& jsonObj, bool recursive)
{
	jsonObj["id"] = _id;
	jsonObj["label"] = CommonHelper::qstringToUtf8(_strDisplayName);
	jsonObj["type"] = _folderType;
	jsonObj["name"] = CommonHelper::qstringToUtf8(_name);
	jsonObj["description"] = CommonHelper::qstringToUtf8(_strDescription);
	jsonObj["classType"] = g_TYPE_DATAPACK;
	jsonObj["canCreateTable"] = CommonHelper::intTobool(_bIsGenerateTable);
	jsonObj["version"] = _wCreateVersion;

	if (recursive) {
		json subPacks;
		QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
		while (it != _childrenMap.end())
		{
			//将对象信息转json
			json child;
			(*it)->toJson(child, recursive);
			subPacks.push_back(child);
			it++;
		}
		jsonObj["children"] = subPacks;
	}
}

//获取子模块
void DataPack::getSubPack(DPData* pManager)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataManager* pMng = qobject_cast<DataManager*>(pManager);
	if (!_initSubPack)
	{
		list<M_FolderDAO*> folderDAOList;
		M_FolderDAO* pCurFolderDAO = dynamic_cast<M_FolderDAO*>(_pDBDAO);
		rm = pCurFolderDAO->getSubFolderDAOList(folderDAOList);
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.getSubFolderDAOList  success");
			for (list<M_FolderDAO*>::iterator it = folderDAOList.begin(); it != folderDAOList.end(); ++it)
			{
				//加载当前模块
				DataPack* pNew = new DataPack();
				pNew->loadData(*it);
				int id = (*it)->_ID;
				// 加入到map
				pNew->_parent = this;
				pNew->_bIsChildPack = true;
				_childrenMap.insert(id, pNew);
				pMng->insertDataMap(DataManager::DataType::dataPack, id, pNew);
				//获取子模块
				pNew->getAllChildren(pMng);
			}
			_initSubPack = true;
		}
		else
		{
			//组件接口执行失败
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.getSubFolderDAOList  failed");
			LOG(ERROR) << rm.rMsg;
		}
	}
}

//获取数据类
void DataPack::getDataClassAndAttribute(DPData* pManager)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataManager* pMng = qobject_cast<DataManager*>(pManager);
	if (!_initDataClass)
	{
		list<M_EntityTableDAO*> tableDAOList;
		M_FolderDAO* pFolderDao = dynamic_cast<M_FolderDAO*>(_pDBDAO);
		rm = pFolderDao->getM_EntityTableDAOList(tableDAOList);
		if (rm.rCode != 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.getM_EntityTableDAOList  failed");
			LOG(ERROR) << rm.rMsg;
			return;
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.getM_EntityTableDAOList  success");

		for (list<M_EntityTableDAO*>::iterator it = tableDAOList.begin(); it != tableDAOList.end(); ++it)
		{
			//加载当前数据类并加到当前数据模块的下层
			DataClass* pNew = new DataClass();
			pNew->loadData(*it);
			int id = (*it)->_ID;
			pNew->_parent = this;
			_childrenMap.insert(id, pNew);
			pMng->insertDataMap(DataManager::DataType::dataClass, id, pNew);
			//获取当前数据类的下层数据属性
			pNew->getAllChildren(pManager);
			//findby
			if (!pNew->getFindByInterface())
			{
				LOG(INFO) << CommonHelper::utf8ToStdString("获取查询接口失败");
			}
			//delby
			if (!pNew->getDelByInterface())
			{
				LOG(INFO) << CommonHelper::utf8ToStdString("获取删除接口失败");
			}
		}
		_initDataClass = true;

	}
	else
	{
		QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
		while (it != _childrenMap.end())
		{
			DataClass* pData = qobject_cast<DataClass*>(*it);
			//将对象信息转json
			json j;
			j["id"] = pData->_id;
			j["label"] = CommonHelper::qstringToUtf8(pData->_strDisplayName);
			j["name"] = CommonHelper::qstringToUtf8(pData->_name);
			j["type"] = pData->_type;
			j["description"] = CommonHelper::qstringToUtf8(pData->_strDescription);
			j["classType"] = g_TYPE_DATACLASS;
			j["createVersion"] = pData->_wCreateVersion;
			j["delVersion"] = pData->_wDeleteVersion;
			j["innerName"] = CommonHelper::qstringToUtf8(pData->_strInternalName);
			j["countType"] = pData->_wCountType;

			it++;
		}
	}

}

/*获取新的属性*/
void DataPack::getNewProperty(json& parameter, QVariantMap& valueMap)
{
	//显示名称、（名称标识）、模块类型、描述，是否生成表
	//name,type,nameFlag,isGenerateTable
	auto data = parameter["data"];
	//显示名称
	valueMap.insert("displayName", CommonHelper::utf8ToQString(data["label"]));
	//模块类型
	valueMap.insert("folderType", (int)data["type"]);
	//名称标识
	if (!data["name"].is_null())
	{
		valueMap.insert("name", CommonHelper::utf8ToQString(data["name"]));
	}
	//描述
	valueMap.insert("description", CommonHelper::utf8ToQString(data["description"]));
	//是否生成表
	valueMap.insert("generateTable", (bool)data["canCreateTable"]);
}

void DataPack::setNewData(json& parameter)
{
	QVariantMap newValues;
	getNewProperty(parameter, newValues);
	setProperties(newValues);
}

/*把当前数据模块移到目的数据模块*/
bool DataPack::moveData(json& parameter, DPData* pManager)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataManager* pMng = qobject_cast<DataManager*>(pManager);
	auto data = parameter["data"];
	//目标模块id
	int dstPackId = data["parentid"];
	//当前模块
	M_FolderDAO* pCurPackDAO = dynamic_cast<M_FolderDAO*>(_pDBDAO);
	//目的模块
	DataPack* pdstPack = qobject_cast<DataPack*>(pMng->findObjectById(DataManager::DataType::dataPack, dstPackId));
	M_FolderDAO* pDstPackDAO = dynamic_cast<M_FolderDAO*>(pdstPack->_pDBDAO);

	//当前数据模块从上层移出（上层结点改变）
	//当前模块是子模块还是模型下挂
	if (pCurPackDAO->_t_M_FolderID > 0)
	{
		//该模块为子模块，查找上层模块结点，移出
		M_FolderDAO* pfatherFolderDAO = dynamic_cast<M_FolderDAO*>(_parent->_pDBDAO);
		if (pfatherFolderDAO)
		{
			//移除该子模块
			rm = pfatherFolderDAO->removeSubFolderDAO(pCurPackDAO);
			if (rm.rCode != 0)
			{
				//移除子模块失败
				LOG(INFO) << CommonHelper::utf8ToStdString(" M_FolderDAO::removeSubFolderDAO failed");
				LOG(ERROR) << rm.rMsg;
				return false;
			}
			else
			{
				LOG(INFO) << CommonHelper::utf8ToStdString(" M_FolderDAO::removeSubFolderDAO success");
			}

		}
		else
		{
			//找不到上层数据模块
			QString msg = "找不到模块" + QString::number(pCurPackDAO->_ID) + "--" + CommonHelper::stringToQstring(pCurPackDAO->_name) + "的上层模块";
			LOG(INFO) << CommonHelper::qstringToString(msg);
			return false;
		}
	}
	else
	{
		//根模块不需要作移出相关操作
	}
	//移入目标模块
	rm = pDstPackDAO->addM_SubFolderDAO(pCurPackDAO);
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO::addM_SubFolderDAO success");
		QString msg = "模块" + QString::number(pCurPackDAO->_ID) + "--" + CommonHelper::stringToQstring(pCurPackDAO->_name) + "移入目标模块" + CommonHelper::stringToQstring(pDstPackDAO->_name) + "成功";
		LOG(INFO) << CommonHelper::qstringToString(msg);
		//移入成功
		_parent->_childrenMap.remove(_id); //内存中移出
		//新的模块内存中加入
		_parent = pdstPack;
		pdstPack->_childrenMap.insert(_id, this);

		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO::addM_SubFolderDAO failed");
		QString msg = "模块" + QString::number(pCurPackDAO->_ID) + "--" + CommonHelper::stringToQstring(pCurPackDAO->_name) + "移入目标模块" + CommonHelper::stringToQstring(pCurPackDAO->_name) + "失败";
		LOG(INFO) << CommonHelper::qstringToString(msg);
		LOG(ERROR) << rm.rMsg;
		return false;
	}
}

bool DataPack::addScene(DPData* pNew)
{
	using namespace  DBPlatformSpace;
	ResultMsg rm;
	SceneInfo* pScene = qobject_cast<SceneInfo*>(pNew);
	//组件添加数据库
	M_FolderDAO* pPackDao = dynamic_cast<M_FolderDAO*>(_pDBDAO);
	pScene->saveToDao();
	M_SceneInfoDAO* pSceneDao = dynamic_cast<M_SceneInfoDAO*>(pScene->_pDBDAO);
	rm = pPackDao->addSceneInfo(pSceneDao);
	if (rm.rCode == 0)
	{
		pScene->_id = pSceneDao->_ID;
		pScene->_parent = this;
		_sceneMap.insert(pScene->_id, pScene);
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.addSceneInfo success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.addSceneInfo failed");
		LOG(INFO) << rm.rMsg;
		return false;
	}
}

bool DataPack::deleteScene(int id)
{
	_sceneMap.remove(id);
	return true;
}

//bool DataPack::moveScene(json& parameter)
//{
//	return true;
//}

bool DataPack::getScene(DPData* pMg)
{
	DataManager* pManager = qobject_cast<DataManager*>(pMg);
	//获取
	using namespace DBPlatformSpace;
	ResultMsg rm;
	list<M_SceneInfoDAO*> sceneList;
	M_FolderDAO* pPackDao = dynamic_cast<M_FolderDAO*>(_pDBDAO);
	rm = pPackDao->getSceneInfoList(sceneList);
	if (rm.rCode == 0)
	{
		for (list<M_SceneInfoDAO*>::iterator it = sceneList.begin(); it != sceneList.end(); ++it)
		{
			SceneInfo* pScene;
			if (_sceneMap.contains((*it)->_ID))
			{
				//确保统一，可从数据库覆盖
				pScene = _sceneMap.value((*it)->_ID);
				pScene->loadData(*it);
			}
			else
			{
				pScene = new SceneInfo();
				pScene->loadData(*it);
				pScene->_parent = this;
				_sceneMap.insert(pScene->_id, pScene);
				pManager->insertDataMap(DataManager::DataType::scene, pScene->_id, pScene);
			}
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.getSceneInfoList success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.getSceneInfoList failed");
		LOG(INFO) << rm.rMsg;
		return false;
	}

}

bool DataPack::generateCode(/*DPData* pManager,*/ QStringList& qfileList)
{
	//代码生成路径？生成文件列表？
	using namespace DBPlatformSpace;
	ResultMsg rm;
	SysManager& sysMgr = GetSysManager();
	QString codeFileFolderPath = sysMgr._codeGeneratePath;
	codeFileFolderPath += "/C++/";
	list<string> fileList;
	// 	DataModelData* pModel = qobject_cast<DataModelData*>(getDataModelOwner());
	// 	M_EntityModelDAO* pModelDao = dynamic_cast<M_EntityModelDAO*>(pModel->_pDBDAO);
	M_FolderDAO* pFolderDao = dynamic_cast<M_FolderDAO*>(_pDBDAO);
	rm = pFolderDao->CreateCode(/*pModelDao, */string(codeFileFolderPath.toLocal8Bit()), fileList);

	if (rm.rCode == 0)
	{
		for (auto i : fileList)
		{
			qfileList.append(CommonHelper::stringToQstring(i));
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.CreateCode   success");
		return true;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("DataPack:M_EntityTableDAO.CreateCode   failed");
	LOG(INFO) << rm.rMsg;
	return false;
}

void DataPack::setFileData(FileGenerate* generator, QStringList flag)
{
	int pos = flag.size(); //替换的标识位置

	if (flag.size() == 1)
	{
		//根模块
		generator->PackItem.append(new CCS_Report::CCSModelDataSet(flag[0]));
		generator->RootPack.append(new CCS_Report::CCSModelDataSet(flag[0], _strDisplayName));
		generator->PackTable.append(new CCS_Report::CCSModelDataSet(flag[0], _strDisplayName, _name, CommonHelper::convertFolderTypeToString(_folderType), CommonHelper::convertPropertyValue(_bIsGenerateTable), ""));

	}
	if (flag.size() == 2)
	{
		//第二层（第一层子模块）
		generator->ChildPackItem.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1]));
		generator->ChildPack1.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], _strDisplayName));
		generator->ChildPackTable.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], _strDisplayName, _name, CommonHelper::convertFolderTypeToString(_folderType), CommonHelper::convertPropertyValue(_bIsGenerateTable), _parent->_name));

	}
	else if (flag.size() == 3)
	{
		//第三层
		generator->Ch_childPackItem.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], flag[2]));
		generator->ChildPack2.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], flag[2], _strDisplayName));
		generator->Ch_childPackTable.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], flag[2], _strDisplayName, _name, CommonHelper::convertFolderTypeToString(_folderType), CommonHelper::convertPropertyValue(_bIsGenerateTable), _parent->_name));

	}
	if (_childrenMap.size() > 0)
	{
		QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
		int id = 0;
		flag << QString::number(id);
		while (it != _childrenMap.end())
		{
			flag.replace(pos, QString::number(id));
			(*it)->setFileData(generator, flag);
			it++;
			id++;
		}
	}

}

//判断名称标识：size>=2且其它满足名称标识命名规则
//true 为不合法 false 为合法
bool DataPack::checkNameillegal( QString& errMsg)
{
	if (_name.size() < 3 || _name.size() > 128)
	{
		errMsg =  _name + " 名称标识长度有误";
		return true;
	}
	else
	{
		if (!_name.at(0).isLetter())
		{
			errMsg = _name + " 模块名称标识首位只能是字母";
			return true;
		}
		if (!_name.at(2).isLetter())
		{
			errMsg = _name +" 模块名称标识第3位只能是字母";
			return true;
		}
		bool foundmatch = false;
		try {
			std::regex re(R"(^[\w\(\)\[\]\（\）]+$)");
			foundmatch = std::regex_search(_name.toStdString(), re);
		}
		catch (std::regex_error& e) {
			// Syntax error in the regular expression
			errMsg = "正则表达式错误: " + QString::fromStdString(e.what());
		}
		if (foundmatch)
		{
			return false;
		}
		else
		{
			errMsg = "模块名称标识 " + _name + " 含无效字符";
			return true;
		}
	}
}