bool gbk_to_utf16( std::wstring& dest, const std::string& src )
{
#ifdef _WIN32
dest.resize(src.size());
const string old_locale = setlocale(LC_CTYPE, NULL);
setlocale(LC_CTYPE, ".936");
size_t unicodeLength = mbstowcs(const_cast<wchar_t*>(dest.data()), src.c_str(), src.size());
setlocale(LC_CTYPE, old_locale.c_str());
if (unicodeLength == -1)
{
dest = L"";
return false;
}
dest.resize(unicodeLength);
#else
string strTmp;
if (!gbk_to_utf8(strTmp, src))
return false;
utf8_to_utf16(dest, strTmp);
if (dest==L"")
{
return false;
}
#endif
return true;
}
int SXmlDocument::Parse(const std::string& str,std::string encoding)
{
int ret=0;
std::string str_in =str;
toLower(encoding);
if (encoding == "utf-16"){
_encoding = encoding;
ret=utf16_to_utf8(str_in,str_in);
if (ret<0)
return -1;
ChangeEncodeDeclaration(str_in,str_in,"utf-16","utf-8");
}else if (encoding == "gbk"){
_encoding = encoding;
ChangeEncodeDeclaration(str_in,str_in,"gbk","utf-8");
ret=gbk_to_utf8(str_in,str_in);
if (ret<0)
return -1;
}else if(encoding == "gb18030"){
_encoding = encoding;
ChangeEncodeDeclaration(str_in,str_in,"gb18030","utf-8");
ret=gbk_to_utf8(str_in,str_in);
if (ret<0)
return -1;
}else if (encoding == "utf-8"){
_encoding = encoding;
ChangeEncodeDeclaration(str_in,str_in,"gbk","utf-8");
}else{
//WEBSEARCH_DEBUG((LM_ERROR, "SXmlDocument::Parse: can not support this encoding %s\n",encoding.c_str()));
return -1;
}
_doc = xmlReadMemory(str_in.c_str(), str_in.length(), NULL, "UTF-8", 0);
if (_doc==NULL)
return -1;
return 0;
}
void utf8_gbk_test(void)
{
//char buf[512] = "外边的字到底怎么为什么有的时候通不过呢";
//utf8_to_gbk(buf, sizeof(buf));
//gbk_to_utf8(buf, sizeof(buf));
char line[MAX_LINE];
int ret = 0;
FILE* fp = fopen("input.txt","r");
FILE* fp_gbk = fopen("out.gbk", "w");
rewind(fp);
while((ret = st_getline(line, fp)) > 0)
{
utf8_to_gbk(line, MAX_LINE);
fputs(line, fp_gbk);
}
fclose(fp);
fclose(fp_gbk);
fp_gbk = fopen("out.gbk", "r");
FILE* fp_utf8 = fopen("out.utf8", "w");
rewind(fp_gbk);
while((ret = st_getline(line, fp_gbk)) > 0)
{
gbk_to_utf8(line, MAX_LINE);
fputs(line, fp_utf8);
}
fclose(fp_gbk);
fclose(fp_utf8);
st_print("TEST TERMINATED!\n");
return;
}
void*
thread_recv(void* args){
assert(args);
assert(g_apex_cfg);
assert(g_zmq_context);
char* broker = (char*)args;
char temp[256];
sprintf(temp, "%s", broker);
char* host = strtok(temp, ":");
char* portstr = strtok(NULL, ":");
assert(host);
assert(portstr);
int port = atoi(portstr);
zbusconn_cfg_t conn_cfg;
memset(&conn_cfg, 0, sizeof(conn_cfg));
conn_cfg.ctx = g_zmq_context;
conn_cfg.verbose = g_apex_cfg->debug;
strcpy(conn_cfg.host, host);
conn_cfg.port = port;
zbusconn_t* zbus_conn = zbusconn_new(&conn_cfg);
zbuswrk_cfg_t wrk_cfg;
memset(&wrk_cfg, 0, sizeof(wrk_cfg));
strcpy(wrk_cfg.service, g_apex_cfg->service_name);
strcpy(wrk_cfg.reg_token, g_apex_cfg->service_regtoken);
strcpy(wrk_cfg.acc_token, g_apex_cfg->service_acctoken);
strcpy(wrk_cfg.mode, MODE_LB);
zbuswrk_t* worker = zbuswrk_new(&wrk_cfg);
assert(worker);
int rc;
char value_data[VALUE_MAX_LEN];
char msg_data[VALUE_MAX_LEN];
HANDLE_CONN apex_conn = Fix_Connect(g_apex_cfg->apex_address,
g_apex_cfg->apex_user,g_apex_cfg->apex_pwd, g_apex_cfg->apex_timeout);
if(apex_conn){
zlog("APEX Connected\n");
}
while(1){
while(!apex_conn){
zlog("APEX(%s) down, reconnecting...\n", g_apex_cfg->apex_address);
apex_conn = Fix_Connect(g_apex_cfg->apex_address,
g_apex_cfg->apex_user,g_apex_cfg->apex_pwd,g_apex_cfg->apex_timeout);
if(apex_conn){
zlog("APEX Connected\n");
}
zclock_sleep(g_apex_cfg->apex_reconnect);
}
zmsg_t* request = zbuswrk_recv(zbus_conn, worker);
if(!request) break;
zframe_t* sock_id, *msg_id;
zbuswrk_get_address(worker, &sock_id, &msg_id);
if(zmsg_frame_size(request) != 2){
zmsg_destroy(&request);
zmsg_t* reply = zmsg_new();
zmsg_push_back(reply, zframe_newstr("400"));
zmsg_push_back(reply, zframe_newstr("request format: <funcid> <json_params>"));
s_client_reply(zbus_conn, sock_id, msg_id, reply);
continue;
}
zframe_t* funcid_frame = zmsg_pop_front(request);
char* funcid_str = zframe_strdup(funcid_frame);
long funcid = atol(funcid_str);
zframe_t* params_frame = zmsg_pop_front(request);
char* params_json = zframe_strdup(params_frame);
HANDLE_SESSION sess = Fix_AllocateSession(apex_conn);
Fix_SetGYDM(sess, "99999998");
Fix_SetFBDM(sess, "9999");
Fix_CreateReq(sess, funcid);
cJSON* json = cJSON_Parse(params_json);
if(json){
cJSON* param = json->child;
while(param && param->string){
long key = atol(param->string);
char* val = param->valuestring;
if(!val) val = "";
char* val_utf8 = utf8_to_gbk(val);
Fix_SetString(sess, key, val_utf8);
delete[] val_utf8;
param = param->next;
}
cJSON_Delete(json);
} else {
zframe_destroy(&funcid_frame);
zfree(funcid_str);
zframe_destroy(¶ms_frame);
zfree(params_json);
zmsg_destroy(&request);
Fix_ReleaseSession(sess);
continue;
}
rc = Fix_Run(sess);
if(rc){
zmsg_t* reply = zmsg_new();
zmsg_push_back(reply, zframe_newstr("200"));
cJSON* root = cJSON_CreateArray();
int rows = Fix_GetCount(sess);
for(int i=0; i<rows; i++){
int cols = Fix_GetColumnCount(sess, i);
cJSON* row = cJSON_CreateObject();
for(int j=0; j<cols; j++){
long key = 0;
int size = VALUE_MAX_LEN;
Fix_GetValWithIdByIndex(sess, i, j, key, value_data, size);
char key_str[32];
sprintf(key_str, "%d", key);
value_data[size] = '\0';
char* value_data_utf8 = gbk_to_utf8(value_data);
cJSON_AddStringToObject(row, key_str, value_data_utf8);
delete[] value_data_utf8;
}
cJSON_AddItemToArray(root, row);
}
if(rows == 0){
Fix_GetItem(sess, FID_MESSAGE, msg_data, sizeof(msg_data));
root->valuestring = msg_data;
}
char* json_data = cJSON_Print(root);
zmsg_push_back(reply, zframe_newstr(json_data));
free(json_data);
s_client_reply(zbus_conn, sock_id, msg_id, reply);
} else {
long code = Fix_GetCode(sess);
Fix_GetErrMsg(sess, msg_data, sizeof(msg_data));
zlog("WARN: APEX failed(code=%d,msg=%s)\n", code, msg_data);
zmsg_t* reply = zmsg_new();
zmsg_push_back(reply, zframe_newstr("500"));
zmsg_push_back(reply, zframe_newstr(msg_data));
s_client_reply(zbus_conn, sock_id, msg_id, reply);
zframe_destroy(&sock_id);
zframe_destroy(&msg_id);
}
Fix_ReleaseSession(sess);
zframe_destroy(&funcid_frame);
zfree(funcid_str);
zframe_destroy(¶ms_frame);
zfree(params_json);
zmsg_destroy(&request);
}
zfree(broker);
zbusconn_destroy(&zbus_conn);
Fix_Close(apex_conn);
return NULL;
}
void CSvsFile::SaveXML()
{
ofstream outStream(m_strFile.c_str());
if (!outStream)
{
string errorStr = m_strFile;
errorStr = errorStr + "打开时候发生错误，请检查是否有其他程序正在使用中！";
GenErr(errorStr);
}
outStream << sStrHeadInfo;
string strTopLeft = m_vecTR[0][0].m_sTDValue;
trim(strTopLeft);
if(strTopLeft.size() >= 5)
{
strTopLeft = strTopLeft.substr(0, 5);
//transform(strTopLeft.begin(), strTopLeft.end(), strTopLeft.begin(), toupper); //这句不知为何运行报错
//if(strcmp(strupr(const_cast<char*>(strTopLeft.c_str())), "NOTE:") == 0 && m_vecTR.size() > 1)
if(strTopLeft == "NOTE:" && m_vecTR.size() > 1)
m_uTitleLineNo = 1;
}
vector<string> m_sColName;
//printf("m_uTitleLineNo = %d, m_vecTR[m_uTitleLineNo].size() = %d\n", m_uTitleLineNo, m_vecTR[m_uTitleLineNo].size());
//m_sColName.resize(m_vecTR[m_uTitleLineNo].size()); //这句不知为何在Release下会报错
for(size_t col = 0; col < m_vecTR[m_uTitleLineNo].size(); ++col)
{
m_sColName.push_back(m_vecTR[m_uTitleLineNo][col].m_sTDValue);
XMLEncode(m_sColName.back(), true);
m_sColName.back() = gbk_to_utf8(m_sColName.back());
}
for(size_t row = 0; row < m_vecTR.size(); ++row)
{
outStream << "<tr>\n";
for(size_t col = 0; col < m_vecTR[row].size(); ++col)
{
outStream << "<td n=\"" << m_sColName[col] << "\">\n<p t=\"";
TableData& aTD = m_vecTR[row][col];
switch(aTD.m_eTDType)
{
case eTDT_None:
outStream << "\"/>";
break;
case eTDT_String:
XMLEncode(aTD.m_sTDValue);
outStream << "string\">" << gbk_to_utf8(aTD.m_sTDValue) << "</p>";
break;
case eTDT_Float:
outStream << "float\">" << aTD.m_sTDValue << "</p>";
break;
default:
{
stringstream str;
str << aTD.m_eTDType;
GenErr("CSvsFile::SaveXML() aTD.m_eTDType类型错误", str.str());
}
}
outStream << "</td>\n";
}
outStream << "</tr>\n";
}
outStream << sStrEndInfo;
outStream.close();
}
