void Dataset::read(std::string filename){
clear();
CDataFile tmpData(filename.c_str(), DF::RF_READ_AS_DOUBLE);
CDataFile tmpClasses(filename.c_str(), DF::RF_READ_AS_STRING);
data = tmpData(0,0,tmpData.GetNumberOfVariables()-2,tmpData.GetNumberOfSamples(0));
for(int i = 0; i < tmpData.GetNumberOfSamples(0); i++){
std::string tmp;
tmpClasses.GetData(tmpData.GetNumberOfVariables()-1,i,tmp);
classnames.push_back(tmp);
}
tmpData.ClearData();
tmpClasses.ClearData();
}
LWRESULT Cx_ZmqBackend::CallBackZmqMsg(DBHandle dbHandle, const uint8_* recv_msg, uint32_ recv_msg_len,
Data_Ptr& ret_data ,uint32_& ret_data_len)
{
if(!recv_msg)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Cx_ZmqBackend::CallBackZmqMsg Param <recv_msg> is NULL");
return LWDP_PARAMETER_ERROR;
}
TS_ZMQ_SERVER_MSG* zMsg = (TS_ZMQ_SERVER_MSG*)recv_msg;
MSG_DELEGATE_MAP::iterator it= mMsgDelegateMap.find(zMsg->msgCode);
if(it != mMsgDelegateMap.end())
{
return it->second(dbHandle, recv_msg, recv_msg_len, ret_data, ret_data_len);
}
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Unknow Request Msg(%x)", zMsg->msgCode);
uint8_* errMsg = new uint8_[sizeof(TS_ZMQ_SERVER_MSG) + sizeof(TS_SERVER_ERROR_BODY)] ;
memset(errMsg, 0, sizeof(TS_ZMQ_SERVER_MSG) + sizeof(TS_SERVER_ERROR_BODY));
TS_ZMQ_SERVER_MSG* errStru = (TS_ZMQ_SERVER_MSG*)errMsg;
memcpy(errStru->deviceId, zMsg->deviceId, sizeof(errStru->deviceId));
errStru->msgCode = (uint32_)TS_SERVER_UNKNOW_MSG;
TS_SERVER_ERROR_BODY* errBody = (TS_SERVER_ERROR_BODY*)errStru->customMsgBody;
errBody->errMsgCode = zMsg->msgCode;
memcpy(errBody->errData, "Unknow Msg", 11);
Data_Ptr tmpData(errMsg);
ret_data = tmpData;
ret_data_len = sizeof(TS_ZMQ_SERVER_MSG) + sizeof(TS_SERVER_ERROR_BODY);
return LWDP_OK;
}
void Project::SetPluginData(const wxString& pluginName, const wxString& data, bool saveToXml)
{
if(!m_doc.IsOk()) {
return ;
}
// locate the 'Plugins' node
wxXmlNode *plugins = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("Plugins"));
if( !plugins ) {
plugins = new wxXmlNode(m_doc.GetRoot(), wxXML_ELEMENT_NODE, wxT("Plugins"));
}
wxXmlNode *plugin = XmlUtils::FindNodeByName(plugins, wxT("Plugin"), pluginName);
if( !plugin ) {
plugin = new wxXmlNode(plugins, wxXML_ELEMENT_NODE, wxT("Plugin"));
plugin->AddProperty(wxT("Name"), pluginName);
}
wxString tmpData ( data );
tmpData.Trim().Trim(false);
XmlUtils::SetCDATANodeContent(plugin, tmpData);
if ( saveToXml ) {
SaveXmlFile();
}
}
bool FrSimCond::test() {
FrSimReg tmpData(1,0);
tmpData = *sensReg;
//FrSimRegVecVal *srvv = sensReg->getVecvalArray();
//printf("Calling test for signal %s with value %d (%d/%d) lastVal is %d\n", sensReg->getName(), tmpData.to_int(),
// srvv[0].aval, srvv[0].bval, lastVal.to_int());
switch(op) {
case Change:
return true;
case Posedge:
if((lastVal) == FrSimReg(1, 0) && (tmpData) == FrSimReg(1, 1) ) {
return true;
} else {
lastVal = tmpData;
return false;
}
case Negedge:
if((lastVal) == FrSimReg(1, 1) && (tmpData) == FrSimReg(1, 0) ) {
return true;
} else {
lastVal = tmpData;
return false;
}
};
return false;
}
BinexData&
updateMessageData(
size_t& offset,
const T& data,
size_t size)
throw(FFStreamError, InvalidParameter)
{
if (size > sizeof(T) )
{
std::ostringstream errStrm;
errStrm << "Invalid data size: " << size;
InvalidParameter ip(errStrm.str() );
GPSTK_THROW(ip);
}
bool littleEndian = ( (syncByte & eBigEndian) == 0) ? true : false;
if (littleEndian == nativeLittleEndian)
{
msg.replace(offset, size, reinterpret_cast<const char*>(&data), size);
}
else
{
T tmpData(data);
BinUtils::twiddle(tmpData);
msg.replace(offset, size, reinterpret_cast<const char*>(&tmpData), size);
}
offset += size;
return *this;
} // BinexData::updateMessageData()
/**
* @brief 解析行数据
* @param data 原始数据
* @param dataSize 数据大小
* @param dataIndex 数据下标
* @param lineData 行数据
* @return 返回解析是否成功
*/
const bool ParseRequestData::lineData(const char* data,
const std::size_t& dataSize,
std::size_t& dataIndex,
std::string& lineData)
{
bool lineEnd = false;
std::string tmpData(data);
lineData.clear();
while (dataIndex < dataSize && !lineEnd) {
char ch = tmpData.at(dataIndex);
switch (ch) {
case '\r':
break;
case '\n':
lineEnd = true;
break;
default:
_bufferLine.push_back(ch);
break;
}
++dataIndex;
}
if (lineEnd) {
lineData.assign(_bufferLine.begin(), _bufferLine.end());
_bufferLine.clear();
}
return lineEnd;
}
void Days::radixSort(vector<node>& data){
size_t size = data.size();
vector<node> tmpData(size);
vector<size_t> counters(size,0);
size_t i,tot,oldCount;
for(i=0;i<size;i++){
counters[data[i].maxLabel-1]++;
}
tot = 0;
for(i=0;i<size;i++){
oldCount = counters[i];
counters[i] = tot;
tot += oldCount;
}
//sort everything by max label, use counters to find the right positions
for(i=0;i<size;i++){
tmpData[counters[data[i].maxLabel-1]] = data[i];
counters[data[i].maxLabel-1]++;
}
for(i=0;i<size;i++){
counters[i] = 0;
}
for(i=0;i<size;i++){
counters[tmpData[i].minLabel-1]++;
}
tot = 0;
for(i=0;i<size;i++){
oldCount = counters[i];
counters[i] = tot;
tot += oldCount;
}
//sort everything by min label, use counters to find the right positions
for(i=0;i<size;i++){
data[counters[tmpData[i].minLabel-1]] = tmpData[i];
counters[tmpData[i].minLabel-1]++;
}
}
// invoke a method
int oDateTime::invokeMethod(qlong pMethodId, EXTCompInfo* pECI) {
switch (pMethodId) {
case 1: { // add seconds
EXTParamInfo* param1 = ECOfindParamNum( pECI, 1 );
EXTfldval tmpData((qfldval) param1->mData);
int tmpSeconds = tmpData.getLong();
setTimestamp(mTimestamp + tmpSeconds);
return 1L;
}; break;
default: {
return oBaseNVComponent::invokeMethod(pMethodId, pECI);
}; break;
}
};
bool AudioAsset::LoadFromRawPCMWavData(const u8 *data, size_t numBytes, bool stereo, bool is16Bit, int frequency)
{
// Clean up the previous OpenAL audio buffer handle, if old data existed.
DoUnload();
#ifndef TUNDRA_NO_AUDIO
if (!data || numBytes == 0)
{
LogError("Null data passed in AudioAsset::LoadFromWavData!");
return false;
}
if (!CreateBuffer())
return false;
ALenum openALFormat;
if (stereo && is16Bit) openALFormat = AL_FORMAT_STEREO16;
else if (!stereo && is16Bit) openALFormat = AL_FORMAT_MONO16;
else if (stereo && !is16Bit) openALFormat = AL_FORMAT_STEREO8;
else /* (!stereo && !is16Bit)*/ openALFormat = AL_FORMAT_MONO8;
// Copy the new data over.
std::vector<u8> tmpData(data, data + numBytes);
alBufferData(handle, openALFormat, &tmpData[0], tmpData.size(), frequency);
ALenum error = alGetError();
if (error != AL_NONE)
{
const ALchar unknownError[] = "unknown error";
const ALchar *errorString = alGetString(error);
if (!errorString)
errorString = unknownError;
LogError("Could not set OpenAL sound buffer data: OpenAL error number " + QString::number(error) + ": " + errorString);
DoUnload();
return false;
}
return true;
#else
return false;
#endif
}
void CCppLanguageTester::test_anonymous_temp_objcet_Life()
{
{
LONG oldCount = CMyTestData::GetTestDataCount();
//匿名对象，尚未出生命周期，立刻就释放了
CMyTestData(1);
LONG newCount = CMyTestData::GetTestDataCount();
CPPUNIT_ASSERT(newCount == oldCount);
}
DECLARE_MYTEST_DATA_COUNT_CHECKER(dataChecker,ctDataCount, 0, __FILE__, __LINE__);
{
LONG oldCount = CMyTestData::GetTestDataCount();
//定义的局部对象，在括号限制的生命周期内
CMyTestData tmpData(1);
LONG newCount = CMyTestData::GetTestDataCount();
//此时尚未出生命周期，因此还有一个
CPPUNIT_ASSERT(newCount == oldCount + 1);
}
}
/*!
* \internal
*/
qint64 QWebSocketPrivate::doWriteFrames(const QByteArray &data, bool isBinary)
{
qint64 payloadWritten = 0;
if (Q_UNLIKELY(!m_pSocket) || (state() != QAbstractSocket::ConnectedState))
return payloadWritten;
Q_Q(QWebSocket);
const QWebSocketProtocol::OpCode firstOpCode = isBinary ?
QWebSocketProtocol::OpCodeBinary : QWebSocketProtocol::OpCodeText;
int numFrames = data.size() / FRAME_SIZE_IN_BYTES;
QByteArray tmpData(data);
tmpData.detach();
char *payload = tmpData.data();
quint64 sizeLeft = quint64(data.size()) % FRAME_SIZE_IN_BYTES;
if (Q_LIKELY(sizeLeft))
++numFrames;
//catch the case where the payload is zero bytes;
//in this case, we still need to send a frame
if (Q_UNLIKELY(numFrames == 0))
numFrames = 1;
quint64 currentPosition = 0;
qint64 bytesWritten = 0;
quint64 bytesLeft = data.size();
for (int i = 0; i < numFrames; ++i) {
quint32 maskingKey = 0;
if (m_mustMask)
maskingKey = generateMaskingKey();
const bool isLastFrame = (i == (numFrames - 1));
const bool isFirstFrame = (i == 0);
const quint64 size = qMin(bytesLeft, FRAME_SIZE_IN_BYTES);
const QWebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode
: QWebSocketProtocol::OpCodeContinue;
//write header
bytesWritten += m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
//write payload
if (Q_LIKELY(size > 0)) {
char *currentData = payload + currentPosition;
if (m_mustMask)
QWebSocketProtocol::mask(currentData, size, maskingKey);
qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
if (Q_LIKELY(written > 0)) {
bytesWritten += written;
payloadWritten += written;
} else {
m_pSocket->flush();
setErrorString(QWebSocket::tr("Error writing bytes to socket: %1.")
.arg(m_pSocket->errorString()));
Q_EMIT q->error(QAbstractSocket::NetworkError);
break;
}
}
currentPosition += size;
bytesLeft -= size;
}
if (Q_UNLIKELY(payloadWritten != data.size())) {
setErrorString(QWebSocket::tr("Bytes written %1 != %2.")
.arg(payloadWritten).arg(data.size()));
Q_EMIT q->error(QAbstractSocket::NetworkError);
}
return payloadWritten;
}
/*!
* \internal
*/
qint64 WebSocket::doWriteFrames(const QByteArray &data, bool isBinary)
{
const WebSocketProtocol::OpCode firstOpCode = isBinary ? WebSocketProtocol::OC_BINARY : WebSocketProtocol::OC_TEXT;
int numFrames = data.size() / FRAME_SIZE_IN_BYTES;
QByteArray tmpData(data);
tmpData.detach();
char *payload = tmpData.data();
quint64 sizeLeft = static_cast<quint64>(data.size()) % FRAME_SIZE_IN_BYTES;
if (sizeLeft)
{
++numFrames;
}
if (numFrames == 0) //catch the case where the payload is zero bytes; in that case, we still need to send a frame
{
numFrames = 1;
}
quint64 currentPosition = 0;
qint64 bytesWritten = 0;
qint64 payloadWritten = 0;
quint64 bytesLeft = data.size();
for (int i = 0; i < numFrames; ++i)
{
quint32 maskingKey = 0;
if (m_mustMask)
{
maskingKey = generateMaskingKey();
}
bool isLastFrame = (i == (numFrames - 1));
bool isFirstFrame = (i == 0);
quint64 size = qMin(bytesLeft, FRAME_SIZE_IN_BYTES);
WebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode : WebSocketProtocol::OC_CONTINUE;
//write header
bytesWritten += m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
//write payload
if (size > 0)
{
char *currentData = payload + currentPosition;
if (m_mustMask)
{
WebSocketProtocol::mask(currentData, size, maskingKey);
}
qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
if (written > 0)
{
bytesWritten += written;
payloadWritten += written;
}
else
{
setErrorString("WebSocket::doWriteFrames: Error writing bytes to socket: " + m_pSocket->errorString());
qDebug() << errorString();
m_pSocket->flush();
Q_EMIT error(QAbstractSocket::NetworkError);
break;
}
}
currentPosition += size;
bytesLeft -= size;
}
if (payloadWritten != data.size())
{
setErrorString("Bytes written " + QString::number(payloadWritten) + " != " + QString::number(data.size()));
qDebug() << errorString();
Q_EMIT error(QAbstractSocket::NetworkError);
}
return payloadWritten;
}
BOOL COpenDlg::OnInitDialog()
{
__super::OnInitDialog();
AppSettings& s = AfxGetAppSettings();
CRecentFileList& MRU = s.MRU;
MRU.ReadList();
m_mrucombo.ResetContent();
for (int i = 0; i < MRU.GetSize(); i++)
if (!MRU[i].IsEmpty()) {
m_mrucombo.AddString(MRU[i]);
}
CorrectComboListWidth(m_mrucombo);
CRecentFileList& MRUDub = s.MRUDub;
MRUDub.ReadList();
m_mrucombo2.ResetContent();
for (int i = 0; i < MRUDub.GetSize(); i++)
if (!MRUDub[i].IsEmpty()) {
m_mrucombo2.AddString(MRUDub[i]);
}
CorrectComboListWidth(m_mrucombo2);
if (m_mrucombo.GetCount() > 0) {
m_mrucombo.SetCurSel(0);
}
if (::IsClipboardFormatAvailable(CF_UNICODETEXT) && ::OpenClipboard(m_hWnd)) {
HGLOBAL hglb = ::GetClipboardData(CF_UNICODETEXT);
if (hglb) {
LPCTSTR pText = (LPCTSTR)::GlobalLock(hglb);
if (pText) {
if (AfxIsValidString(pText)) {
CString tmpData(CString(pText).MakeLower());
if (PlayerYouTubeCheck(tmpData) || PlayerYouTubePlaylistCheck(tmpData)) {
m_mrucombo.SetWindowTextW(pText);
}
}
GlobalUnlock(hglb);
}
}
CloseClipboard();
}
m_fns.RemoveAll();
m_path.Empty();
m_path2.Empty();
m_fMultipleFiles = false;
m_fAppendPlaylist = FALSE;
AddAnchor(m_mrucombo, TOP_LEFT, TOP_RIGHT);
AddAnchor(m_mrucombo2, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_BUTTON1, TOP_RIGHT);
AddAnchor(IDC_BUTTON2, TOP_RIGHT);
AddAnchor(IDOK, TOP_RIGHT);
AddAnchor(IDCANCEL, TOP_RIGHT);
AddAnchor(IDC_STATIC1, TOP_LEFT, TOP_RIGHT);
CRect r;
GetWindowRect(r);
CSize sr = r.Size();
SetMinTrackSize(sr);
sr.cx = 1000;
SetMaxTrackSize(sr);
if (m_hIcon != NULL) {
CStatic *pStat = (CStatic*)GetDlgItem(IDC_MAINFRAME_ICON);
pStat->SetIcon(m_hIcon);
}
return TRUE;
}
void Project::SetReconciliationData(const wxString& toplevelDir, const wxString& extensions, const wxArrayString& ignoreFiles, const wxArrayString& excludePaths, wxArrayString& regexes)
{
if (!m_doc.IsOk()) {
return;
}
wxXmlNode* reconciliation = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("Reconciliation"));
if (!reconciliation) {
reconciliation = new wxXmlNode(m_doc.GetRoot(), wxXML_ELEMENT_NODE, wxT("Reconciliation"));
}
wxXmlNode* dirnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Topleveldir"));
if (!dirnode) {
dirnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Topleveldir"));
}
XmlUtils::SetNodeContent(dirnode, toplevelDir);
wxXmlNode* extsnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Extensions"));
if (!extsnode) {
extsnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Extensions"));
}
wxString tmpData(extensions);
tmpData.Trim().Trim(false);
XmlUtils::SetCDATANodeContent(extsnode, tmpData);
wxXmlNode* ignorefilesnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Ignorefiles"));
if (!ignorefilesnode) {
ignorefilesnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Ignorefiles"));
} else {
XmlUtils::RemoveChildren(ignorefilesnode);
}
for (size_t n = 0; n < ignoreFiles.GetCount(); ++n) {
wxXmlNode* pathnode = new wxXmlNode(ignorefilesnode, wxXML_ELEMENT_NODE, "Ignore");
XmlUtils::SetNodeContent(pathnode, ignoreFiles.Item(n));
}
wxXmlNode* excludesnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Excludepaths"));
if (!excludesnode) {
excludesnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Excludepaths"));
} else {
XmlUtils::RemoveChildren(excludesnode);
}
for (size_t n = 0; n < excludePaths.GetCount(); ++n) {
wxXmlNode* pathnode = new wxXmlNode(excludesnode, wxXML_ELEMENT_NODE, "Path");
XmlUtils::SetNodeContent(pathnode, excludePaths.Item(n));
}
wxXmlNode* regexnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Regexes"));
if (!regexnode) {
regexnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Regexes"));
} else {
XmlUtils::RemoveChildren(regexnode);
}
for (size_t n = 0; n < regexes.GetCount(); ++n) {
wxXmlNode* itemnode = new wxXmlNode(regexnode, wxXML_ELEMENT_NODE, "Regex");
XmlUtils::SetNodeContent(itemnode, regexes.Item(n));
}
SaveXmlFile();
}
void ExportLanguage()
{
std::map<uint32_t, std::map<ELanguageType, TString> > languageServerErrCodeMap;
ReadServerErrCodeFile(languageServerErrCodeMap);
std::map<TString, std::map<ELanguageType, TString> >& languageMap = CLanguageManager::GetInstance()->GetLanguageMap();
// 1. Export Bin File.
CSerializer fileData;
for (int i = 0; i < eLT_Count; ++i)
{
fileData << languageMap.size();
for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter)
{
auto subIter = iter->second.find((ELanguageType)i);
if (subIter != iter->second.end())
{
fileData << subIter->second;
}
else
{
fileData << iter->first;
}
}
bool bRet = false;
for (auto iter : languageServerErrCodeMap)
{
auto subIter = iter.second.find((ELanguageType)i);
if (subIter != iter.second.end())
{
if (!bRet)
{
fileData << languageServerErrCodeMap.size();
bRet = true;
}
fileData << iter.first;
fileData << iter.second[(ELanguageType)i];
}
}
TString strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Language);
strFilePath.append(_T("/")).append(pszLanguageTypeString[i]).append(_T(".bin"));
fileData.Deserialize(strFilePath.c_str(), _T("wb+"));
fileData.Reset();
}
//2. Export enum file.
std::string content;
content.append("#ifndef BEYONDENGINEEDITOR_LANGUAGEENUM_H__INCLUDE\n#define BEYONDENGINEEDITOR_LANGUAGEENUM_H__INCLUDE\n").append("\nenum ELanguageTextType\n{\n");
for (auto iter = languageMap.begin(); iter != languageMap.end(); iter++)
{
content.append(" ").append(iter->first.c_str()).append(",\n");
}
content.append("\n eL_Count,\n").append(" eL_Force32Bit = 0xFFFFFFFF\n};\n");
content.append("#define LUA_LANGUAGE_MAP(LM)\\\n");
int32_t nCounter = 0;
for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter)
{
TCHAR szValueBuffer[32];
_stprintf(szValueBuffer, "%d", nCounter++);
content.append(" ").append("LM(").append(iter->first.c_str()).append(",").append(szValueBuffer).append(")\\\n");
}
content.append("\n#endif");
fileData.Reset();
fileData << content;
fileData.SetWritePos(fileData.GetWritePos() - 1);// back scape the 0 in the string end.
bool bFileTheSame = false;
const TString strHeaderFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_SourceCode) + _T("/Language/Language.h");
if (CFilePathTool::GetInstance()->Exists(strHeaderFilePath.c_str()))
{
CSerializer tmpData(strHeaderFilePath.c_str(), "rb");
if (tmpData.GetWritePos() == fileData.GetWritePos())
{
CMD5 tmpMD5(tmpData.GetBuffer(), tmpData.GetWritePos());
CMD5 currentMD5(fileData.GetBuffer(), fileData.GetWritePos());
bFileTheSame = tmpMD5 == currentMD5;
}
}
if (!bFileTheSame)
{
fileData.Deserialize(strHeaderFilePath.c_str(), _T("wb+"));
}
//3. Export txt file.
for (int i = 0; i < eLT_Count; ++i)
{
bool bHasData = false;
fileData.Reset();
for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter)
{
auto subIter = iter->second.find((ELanguageType)i);
if (subIter != iter->second.end())
{
TString strData = (TString)(wxString::FromUTF8(subIter->second.c_str()));
if (!bHasData && !strData.empty())
{
bHasData = true;
}
fileData << strData;
fileData.SetWritePos(fileData.GetWritePos() - 1);
}
fileData << "\n";
fileData.SetWritePos(fileData.GetWritePos() - 1);
}
if (bHasData)
{
TString strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Resource);
strFilePath.append(_T("/")).append(pszLanguageTypeString[i]).append(_T(".txt"));
fileData.Deserialize(strFilePath.c_str(), _T("wt+"));
}
}
fileData.Reset();
const std::map<TString, TString>& languageTagMap = CLanguageManager::GetInstance()->GetLanguageTagMap();
for (auto iter = languageTagMap.begin(); iter != languageTagMap.end(); ++iter)
{
TString strData = (TString)(wxString::FromUTF8(iter->second.c_str()));
fileData << strData;
fileData.SetWritePos(fileData.GetWritePos() - 1);
fileData << "\n";
fileData.SetWritePos(fileData.GetWritePos() - 1);
}
TString strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Resource);
strFilePath.append(_T("/")).append("Tag").append(_T(".txt"));
fileData.Deserialize(strFilePath.c_str(), _T("wt+"));
fileData.Reset();
for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter)
{
TString strData = (TString)(wxString::FromUTF8(iter->first.c_str()));
fileData << strData;
fileData.SetWritePos(fileData.GetWritePos() - 1);
fileData << "\n";
fileData.SetWritePos(fileData.GetWritePos() - 1);
}
strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Resource);
strFilePath.append(_T("/")).append(_T("Enum.txt"));
fileData.Deserialize(strFilePath.c_str(), _T("wt+"));
}