static bool
pyobj2doc(PyObject *object, rapidjson::Value& doc, rapidjson::Document& root)
{
if (PyBool_Check(object)) {
if (Py_True == object) {
doc.SetBool(true);
}
else {
doc.SetBool(false);
}
}
else if (Py_None == object) {
doc.SetNull();
}
else if (PyFloat_Check(object)) {
doc.SetDouble(PyFloat_AsDouble(object));
}
else if (PyInt_Check(object)) {
doc.SetInt64(PyLong_AsLong(object));
}
else if (PyString_Check(object)) {
doc.SetString(PyString_AsString(object), PyString_GET_SIZE(object));
}
else if (PyUnicode_Check(object)) {
PyObject *utf8_item = PyUnicode_AsUTF8String(object);
if (!utf8_item) {
PyErr_SetString(PyExc_RuntimeError, "codec error.");
return false;
}
#ifdef PY3
doc.SetString(PyBytes_AsString(utf8_item), PyBytes_GET_SIZE(utf8_item), root.GetAllocator());
#else
doc.SetString(PyString_AsString(utf8_item), PyString_GET_SIZE(utf8_item), root.GetAllocator());
#endif
Py_XDECREF(utf8_item);
}
else if (PyTuple_Check(object)) {
int len = PyTuple_Size(object), i;
doc.SetArray();
rapidjson::Value _v;
for (i = 0; i < len; ++i) {
PyObject *elm = PyTuple_GetItem(object, i);
if (false == pyobj2doc(elm, _v, root)) {
return false;
}
doc.PushBack(_v, root.GetAllocator());
}
}
else if (PyList_Check(object)) {
int len = PyList_Size(object), i;
doc.SetArray();
rapidjson::Value _v;
for (i = 0; i < len; ++i) {
PyObject *elm = PyList_GetItem(object, i);
if (false == pyobj2doc(elm, _v, root)) {
return false;
}
doc.PushBack(_v, root.GetAllocator());
}
}
else if (PyDict_Check(object)) {
doc.SetObject();
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(object, &pos, &key, &value)) {
if (false == pyobj2doc_pair(key, value, doc, root)) {
return false;
}
}
}
else {
PyErr_SetString(PyExc_RuntimeError, "invalid python object");
return false;
}
return true;
}
void Robot::Process_Register(rapidjson::Document& jsRequest, rapidjson::Document& jsResponse, string& sResponse)
{
rapidjson::Document::AllocatorType& allocator = jsResponse.GetAllocator();
int nErrcode = 0;
string sErrmsg = "ok";
if (!IsRegistered())
{
jsResponse.AddMember("question_bank_version", "1", allocator);
string sRobotid = "";
if (jsRequest.HasMember("body") && jsRequest["body"].IsObject())
{
rapidjson::Value& body = jsRequest["body"];
if (body.HasMember("robot_id") && body["robot_id"].IsString())
{
sRobotid = body["robot_id"].GetString();
}
else if (jsRequest.HasMember("mac") && jsRequest["mac"].IsObject())
{
sRobotid = body["mac"].GetString();
}
if (!sRobotid.empty())
{
// 清除robot_id对应的旧链接
SAContainerSingleLock csl(&RobotService::instance().m_robotManager.m_mapRobot, true);
SPRobotPtr spRobot = RobotService::instance().m_robotManager.FindRobot(sRobotid);
bool bSuccess = true;
if (spRobot)
{
if (spRobot->isCreateisElapsed(10000))
{ // 旧链接创建超过10s,可踢掉
log.error( format("break session '%s'",spRobot->GetRobotID()));
spRobot->Close();
spRobot->SetValid(false);
}
else
{
log.warning(format("connect frequency too high,reserve old connection'%s'!", spRobot->GetRobotID()));
SATCPConnectionPtr spSocket = m_spSocket;
spSocket->Close();
bSuccess = false;
nErrcode = 6;
sErrmsg = "connect frequency too high,reserve old connection!";
}
}
if (bSuccess)
{
m_bIsRegistered = true;
m_sID = sRobotid;
RobotService::instance().m_robotManager.AddRobot(GetRobotPtr());
//RobotService::instance().m_mapUnkownList.RemoveKey(m_sClient);
}
csl.Unlock();
}
else
{
nErrcode = 8;
sErrmsg = "invalid msg data,miss robot_id param!";
log.warning("invalid msg data,miss robot_id param!");
}
}
else
{
nErrcode = 7;
sErrmsg = "invalid msg data,miss necessary param!";
log.warning("invalid msg data,miss necessary param!");
}
}
else
{
nErrcode = 5;
sErrmsg = "Process register failed,already registered!";
log.error("Process register failed,already registered!");
}
jsResponse.AddMember("errcode", 0, allocator);
jsResponse.AddMember("errmsg", "ok", allocator);
sResponse = JsonDocToString(jsResponse);
}
void MainWindow::addOptionsToDoc(rapidjson::Document &doc) {
rapidjson::Value options(rapidjson::kObjectType);
if (nodalDispCheckBox->isChecked()) {
options.AddMember("save_nodal_displacements", true, doc.GetAllocator());
rapidjson::Value rj_val;
std::string val = nodalDispLineEdit->displayText().toStdString();
rj_val.SetString(val.c_str(), val.length(), doc.GetAllocator());
options.AddMember("nodal_displacements_filename", rj_val, doc.GetAllocator());
}
if (nodalForcesCheckBox->isChecked()) {
options.AddMember("save_nodal_forces", true, doc.GetAllocator());
rapidjson::Value rj_val;
std::string val = nodalForcesLineEdit->displayText().toStdString();
rj_val.SetString(val.c_str(), val.length(), doc.GetAllocator());
options.AddMember("nodal_forces_filename", rj_val, doc.GetAllocator());
}
if (tieForcesCheckBox->isChecked()) {
options.AddMember("save_tie_forces", true, doc.GetAllocator());
rapidjson::Value rj_val;
std::string val = tieForcesLineEdit->displayText().toStdString();
rj_val.SetString(val.c_str(), val.length(), doc.GetAllocator());
options.AddMember("ties_forces_filename", rj_val, doc.GetAllocator());
}
if (reportCheckBox->isChecked()) {
options.AddMember("save_report", true, doc.GetAllocator());
rapidjson::Value rj_val;
std::string val = tieForcesLineEdit->displayText().toStdString();
rj_val.SetString(val.c_str(), val.length(), doc.GetAllocator());
options.AddMember("report_filename", rj_val, doc.GetAllocator());
}
options.AddMember("verbose", true, doc.GetAllocator());
doc.AddMember("options", options, doc.GetAllocator());
}
void preprocess_types(rapidjson::Document & d)
{
/// pre record types
for (auto & itr : d.GetArray()) {
RAPIDJSON_ASSERT(itr.HasMember("category"));
RAPIDJSON_ASSERT(itr.HasMember("name"));
ensure_has_array_mem(itr, "attr", d);
ensure_has_array_mem(itr, "msgid", d);
ensure_has_object_mem(itr, "fields", d);
ensure_has_array_mem(itr, "alias", d);
s_type_lists[itr.FindMember("name")->value.GetString()] = &itr;
for (auto & alias : itr.FindMember("alias")->value.GetArray()) {
s_alias_lists[alias.GetString()] = & itr;
}
s_type_order.push_back(&itr);
}
/// messages enum
for (auto & itr : d.GetArray()) {
bool has_attr_msg = false;
rapidjson::Value & attr_val = itr.FindMember("attr")->value;
for (auto & sattr : attr_val.GetArray()) {
RAPIDJSON_ASSERT(sattr.IsString());
if (sattr == "msg") {
has_attr_msg = true;
attr_val.GetArray().Erase(&sattr);
}
else if (sattr == "export") {
s_export_order.push_back(&itr);
}
else if (sattr == "pqxx") {
add_pqxx(d, itr, true);
}
}
rapidjson::Value & msgid_val = itr.FindMember("msgid")->value;
if (has_attr_msg) {
RAPIDJSON_ASSERT(itr.HasMember("name"));
rapidjson::Value new_name(itr.FindMember("name")->value, d.GetAllocator());
msgid_val.PushBack(new_name, d.GetAllocator());
}
for (const auto & smsgid : msgid_val.GetArray()) {
RAPIDJSON_ASSERT(smsgid.IsString());
s_msg_lists[smsgid.GetString()] = &itr;
}
if (msgid_val.GetArray().Size() > 0) {
s_msg_order.push_back(&itr);
}
if (msgid_val.GetArray().Size() == 0) {
itr.RemoveMember("msgid");
}
}
for (auto i : s_pqxx_order) {
std::cout << "\t" << i->FindMember("name")->value.GetString() << std::endl;;
}
}
static void
pyobj2doc(PyObject *object, rapidjson::Document& doc)
{
if (PyBool_Check(object)) {
if (Py_True == object) {
doc.SetBool(true);
}
else {
doc.SetBool(false);
}
}
else if (Py_None == object) {
doc.SetNull();
}
else if (PyFloat_Check(object)) {
doc.SetDouble(PyFloat_AsDouble(object));
}
else if (PyInt_Check(object)) {
doc.SetInt(PyLong_AsLong(object));
}
else if (PyString_Check(object)) {
doc.SetString(PyString_AsString(object), PyString_GET_SIZE(object));
}
else if (PyUnicode_Check(object)) {
#ifdef PY3
PyObject *utf8_item;
utf8_item = PyUnicode_AsUTF8String(object);
if (!utf8_item) {
// TODO: error handling
printf("error\n");
}
doc.SetString(PyBytes_AsString(utf8_item),
PyBytes_Size(utf8_item), doc.GetAllocator());
Py_XDECREF(utf8_item);
#else
doc.SetString(PyBytes_AsString(object), PyBytes_GET_SIZE(object));
#endif
}
else if (PyTuple_Check(object)) {
int len = PyTuple_Size(object), i;
doc.SetArray();
rapidjson::Value _v;
for (i = 0; i < len; ++i) {
PyObject *elm = PyList_GetItem(object, i);
pyobj2doc(elm, _v, doc);
doc.PushBack(_v, doc.GetAllocator());
}
}
else if (PyList_Check(object)) {
int len = PyList_Size(object), i;
doc.SetArray();
rapidjson::Value _v;
for (i = 0; i < len; ++i) {
PyObject *elm = PyList_GetItem(object, i);
pyobj2doc(elm, _v, doc);
doc.PushBack(_v, doc.GetAllocator());
}
}
else if (PyDict_Check(object)) {
doc.SetObject();
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(object, &pos, &key, &value)) {
pyobj2doc_pair(key, value, doc);
}
}
else {
// TODO: error handle
}
}
void save(const int &value, rapidjson::Value &json, rapidjson::Document &document)
{
rapidjson::Value v(rapidjson::kNumberType);
v.SetInt(value);
json.AddMember("int", v, document.GetAllocator());
}
void save(const std::string &value, rapidjson::Value &json, rapidjson::Document &document)
{
rapidjson::Value v(rapidjson::kArrayType);
json.AddMember("string", value.c_str(), document.GetAllocator());
}
void save(const glm::uvec2 &value, rapidjson::Value &json, rapidjson::Document &document)
{
rapidjson::Value v(rapidjson::kArrayType);
v.PushBack(value.x, document.GetAllocator()).PushBack(value.y, document.GetAllocator());
json.AddMember("uvec2", v, document.GetAllocator());
}
void TriggerMng::buildJson(rapidjson::Document &document, cocostudio::CocoLoader *pCocoLoader, cocostudio::stExpCocoNode *pCocoNode)
{
int count = pCocoNode[13].GetChildNum();
int length = 0;
int num = 0;
int size = 0;
int extent = 0;
int border = 0;
std::string key0;
stExpCocoNode *pTriggersArray = pCocoNode[13].GetChildArray(pCocoLoader);
document.SetArray();
rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
for (int i0 = 0; i0 < count; ++i0)
{
rapidjson::Value vElemItem(rapidjson::kObjectType);
border = pTriggersArray[i0].GetChildNum();
stExpCocoNode *pTriggerArray = pTriggersArray[i0].GetChildArray(pCocoLoader);
for (int i1 = 0; i1 < border; ++i1)
{
std::string key1 = pTriggerArray[i1].GetName(pCocoLoader);
const char *str1 = pTriggerArray[i1].GetValue(pCocoLoader);
if (key1.compare("actions") == 0)
{
rapidjson::Value actionsItem(rapidjson::kArrayType);
length = pTriggerArray[i1].GetChildNum();
stExpCocoNode *pActionsArray = pTriggerArray[i1].GetChildArray(pCocoLoader);
for (int i2 = 0; i2 < length; ++i2)
{
rapidjson::Value action(rapidjson::kObjectType);
num = pActionsArray[i2].GetChildNum();
stExpCocoNode *pActionArray = pActionsArray[i2].GetChildArray(pCocoLoader);
for (int i3 = 0; i3 < num; ++i3)
{
std::string key2 = pActionArray[i3].GetName(pCocoLoader);
const char *str2 = pActionArray[i3].GetValue(pCocoLoader);
if (key2.compare("classname") == 0)
{
if (str2 != nullptr)
{
action.AddMember("classname", rapidjson::Value(str2,allocator), allocator);
}
}
else if (key2.compare("dataitems") == 0)
{
rapidjson::Value dataitems(rapidjson::kArrayType);
size = pActionArray[i3].GetChildNum();
stExpCocoNode *pDataItemsArray = pActionArray[i3].GetChildArray(pCocoLoader);
for (int i4 = 0; i4 < size; ++i4)
{
rapidjson::Value dataitem(rapidjson::kObjectType);
extent = pDataItemsArray[i4].GetChildNum();
stExpCocoNode *pDataItemArray = pDataItemsArray[i4].GetChildArray(pCocoLoader);
for (int i5 = 0; i5 < extent; ++i5)
{
std::string key3 = pDataItemArray[i5].GetName(pCocoLoader);
const char *str3 = pDataItemArray[i5].GetValue(pCocoLoader);
if (key3.compare("key") == 0)
{
if (str3 != nullptr)
{
dataitem.AddMember("key", rapidjson::Value(str3,allocator), allocator);
}
}
else
{
rapidjson::Type type = pDataItemArray[i5].GetType(pCocoLoader);
if (type == rapidjson::kStringType)
{
dataitem.AddMember("value", rapidjson::Value(str3,allocator), allocator);
}
else
{
int nV = atoi(str3);
float fV = utils::atof(str3);
if (fabs(nV - fV) < 0.0000001)
{
dataitem.AddMember("value", nV, allocator);
}
else
{
dataitem.AddMember("value", fV, allocator);
}
}
}
}
dataitems.PushBack(dataitem, allocator);
}
action.AddMember("dataitems", dataitems, allocator);
}
}
actionsItem.PushBack(action, allocator);
}
vElemItem.AddMember("actions", actionsItem, allocator);
}
else if (key1.compare("conditions") == 0)
{
rapidjson::Value condsItem(rapidjson::kArrayType);
length = pTriggerArray[i1].GetChildNum();
stExpCocoNode *pConditionsArray = pTriggerArray[i1].GetChildArray(pCocoLoader);
for (int i6 = 0; i6 < length; ++i6)
{
rapidjson::Value cond(rapidjson::kObjectType);
num = pConditionsArray[i6].GetChildNum();
stExpCocoNode *pConditionArray = pConditionsArray[i6].GetChildArray(pCocoLoader);
for (int i7 = 0; i7 < num; ++i7)
{
std::string key4 = pConditionArray[i7].GetName(pCocoLoader);
const char *str4 = pConditionArray[i7].GetValue(pCocoLoader);
if (key4.compare("classname") == 0)
{
if (str4 != nullptr)
{
cond.AddMember("classname", rapidjson::Value(str4,allocator), allocator);
}
}
else if (key4.compare("dataitems") == 0)
{
rapidjson::Value dataitems(rapidjson::kArrayType);
size = pConditionArray[i7].GetChildNum();
stExpCocoNode *pDataItemsArray = pConditionArray[i7].GetChildArray(pCocoLoader);
for (int i8 = 0; i8 < size; ++i8)
{
rapidjson::Value dataitem(rapidjson::kObjectType);
extent = pDataItemsArray[i8].GetChildNum();
stExpCocoNode *pDataItemArray = pDataItemsArray[i8].GetChildArray(pCocoLoader);
for (int i9 = 0; i9 < extent; ++i9)
{
std::string key5 = pDataItemArray[i9].GetName(pCocoLoader);
const char *str5 = pDataItemArray[i9].GetValue(pCocoLoader);
if (key5.compare("key") == 0)
{
if (str5 != nullptr)
{
dataitem.AddMember("key", rapidjson::Value(str5,allocator), allocator);
}
}
else
{
rapidjson::Type type = pDataItemArray[i9].GetType(pCocoLoader);
if (type == rapidjson::kStringType)
{
dataitem.AddMember("value", rapidjson::Value(str5,allocator), allocator);
}
else
{
int nV = atoi(str5);
float fV = utils::atof(str5);
if (fabs(nV - fV) < 0.0000001)
{
dataitem.AddMember("value", nV, allocator);
}
else
{
dataitem.AddMember("value", fV, allocator);
}
}
}
}
dataitems.PushBack(dataitem, allocator);
}
cond.AddMember("dataitems", dataitems, allocator);
}
}
condsItem.PushBack(cond, allocator);
}
vElemItem.AddMember("conditions", condsItem, allocator);
}
else if (key1.compare("events") == 0)
{
rapidjson::Value eventsItem(rapidjson::kArrayType);
length = pTriggerArray[i1].GetChildNum();
stExpCocoNode *pEventsArray = pTriggerArray[i1].GetChildArray(pCocoLoader);
for (int i10 = 0; i10 < length; ++i10)
{
rapidjson::Value event(rapidjson::kObjectType);
stExpCocoNode *pEventArray = pEventsArray->GetChildArray(pCocoLoader);
std::string key6 = pEventArray[0].GetName(pCocoLoader);
const char *str6 = pEventArray[0].GetValue(pCocoLoader);
if (key6.compare("id") == 0 && str6 != nullptr)
{
event.AddMember("id", atoi(str6), allocator);
eventsItem.PushBack(event, allocator);
}
}
vElemItem.AddMember("events", eventsItem, allocator);
}
else if (key1.compare("id") == 0)
{
if (str1 != nullptr)
{
vElemItem.AddMember("id", atoi(str1), allocator);
}
}
}
document.PushBack(vElemItem, allocator);
}
}
rapidjson::Value xmrig::String::toJSON(rapidjson::Document &doc) const
{
using namespace rapidjson;
return isNull() ? Value(kNullType) : Value(m_data, doc.GetAllocator());
}
