void
BlackboardGraph::to_json_value(rapidjson::Document& d, rapidjson::Value& v) const
{
rapidjson::Document::AllocatorType& allocator = d.GetAllocator();
v.SetObject();
// Avoid unused variable warnings
(void)allocator;
if (kind_) {
rapidjson::Value v_kind;
v_kind.SetString(*kind_, allocator);
v.AddMember("kind", v_kind, allocator);
}
if (apiVersion_) {
rapidjson::Value v_apiVersion;
v_apiVersion.SetString(*apiVersion_, allocator);
v.AddMember("apiVersion", v_apiVersion, allocator);
}
if (dotgraph_) {
rapidjson::Value v_dotgraph;
v_dotgraph.SetString(*dotgraph_, allocator);
v.AddMember("dotgraph", v_dotgraph, allocator);
}
}
/*
* generate from "sync_conf.json": "jos_lib::NetworkConf"
*/
bool Serialize(const jos_lib::NetworkConf& obj_val, jos_lib::Allocator& alloc, rapidjson::Value& json_val)
{
do
{
json_val.SetObject();
// fields from "jos_lib::NetworkConf"
if (!Serialize(obj_val.port, "port", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.backlog, "backlog", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.enable_reuseport, "enable_reuseport", alloc, json_val)) break; // @(field_type : bool)
if (!Serialize(obj_val.enable_nodelay, "enable_nodelay", alloc, json_val)) break; // @(field_type : bool)
if (!Serialize(obj_val.enable_defer_accept, "enable_defer_accept", alloc, json_val)) break; // @(field_type : bool)
if (!Serialize(obj_val.max_body_size, "max_body_size", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.max_keepalive_requests, "max_keepalive_requests", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.recv_timeout, "recv_timeout", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.send_timeout, "send_timeout", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.threads, "threads", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.user, "user", alloc, json_val)) break; // @(field_type : std::string)
if (!Serialize(obj_val.passwd, "passwd", alloc, json_val)) break; // @(field_type : std::string)
if (!Serialize(obj_val.access_allow, "access_allow", alloc, json_val)) break; // @(field_type : std::string)
return true;
} while (0);
return false;
}
void
SkillInfo::to_json_value(rapidjson::Document& d, rapidjson::Value& v) const
{
rapidjson::Document::AllocatorType& allocator = d.GetAllocator();
v.SetObject();
// Avoid unused variable warnings
(void)allocator;
if (kind_) {
rapidjson::Value v_kind;
v_kind.SetString(*kind_, allocator);
v.AddMember("kind", v_kind, allocator);
}
if (apiVersion_) {
rapidjson::Value v_apiVersion;
v_apiVersion.SetString(*apiVersion_, allocator);
v.AddMember("apiVersion", v_apiVersion, allocator);
}
if (name_) {
rapidjson::Value v_name;
v_name.SetString(*name_, allocator);
v.AddMember("name", v_name, allocator);
}
}
void jsonifyModule(const Module& module, rapidjson::Value& moduleValue, rapidjson::Document& document){
moduleValue.SetObject();
moduleValue.AddMember("name", module.getName().c_str(), document.GetAllocator());
moduleValue.AddMember("description", module.getDescription().c_str(), document.GetAllocator());
moduleValue.AddMember("type", module.getType().getName().c_str(), document.GetAllocator());
//add inputs
rapidjson::Value inputsValue;
inputsValue.SetObject();
for(unsigned int i=0; i<module.getInputSize(); ++i){
auto inputLink = module.getInput(i);
auto outputLink = inputLink->getOutputLink();
//only add connected links
if(outputLink){
std::string sourceString = outputLink->getOwner().getName() + "." + outputLink->getModuleOutput().getName();
rapidjson::Value source(sourceString.c_str(), document.GetAllocator());
rapidjson::Value inputName(inputLink->getModuleInput().getName().c_str(), document.GetAllocator());
inputsValue.AddMember(inputName, source, document.GetAllocator());
} else {
//add custom unlinked values
rapidjson::Value vectorValue;
vectorValue.SetArray();
auto unlinkedValue = inputLink->getUnlinkedValue();
for(int j=0; j<unlinkedValue.getSignalType().dimensionality; ++j){
vectorValue.PushBack(unlinkedValue[j], document.GetAllocator());
}
rapidjson::Value inputName(inputLink->getModuleInput().getName().c_str(), document.GetAllocator());
inputsValue.AddMember(inputName, vectorValue, document.GetAllocator());
}
}
moduleValue.AddMember("inputs", inputsValue, document.GetAllocator());
}
void jsonValueToRapidJSON(JSONValue* value, rapidjson::Value& rapidValue, rapidjson::Document& document) {
JSONNull* nullValue = dynamic_cast<JSONNull*>(value);
if (nullValue) {
rapidValue.SetNull();
return;
}
JSONNumber* numberValue = dynamic_cast<JSONNumber*>(value);
if (numberValue) {
if (numberValue->canBeUInt64()) {
rapidValue.SetUint64(numberValue->getUInt64Value());
}
else if (numberValue->canBeInt64()) {
rapidValue.SetInt64(numberValue->getInt64Value());
}
else {
rapidValue.SetDouble(numberValue->getDoubleValue());
}
return;
}
JSONString* stringValue = dynamic_cast<JSONString*>(value);
if (stringValue) {
rapidValue.SetString(stringValue->getValue().c_str(), stringValue->getValue().size(), document.GetAllocator());
return;
}
JSONBool* boolValue = dynamic_cast<JSONBool*>(value);
if (boolValue) {
rapidValue.SetBool(boolValue->getValue());
return;
}
JSONArray* arrayValue = dynamic_cast<JSONArray*>(value);
if (arrayValue) {
rapidValue.SetArray();
std::vector<JSONValue::ref> values = arrayValue->getValues();
for (auto & value : values) {
rapidjson::Value obj;
jsonValueToRapidJSON(value.get(), obj, document);
rapidValue.PushBack(obj, document.GetAllocator());
}
return;
}
JSONObject* objectValue = dynamic_cast<JSONObject*>(value);
if (objectValue) {
rapidValue.SetObject();
typedef std::map<std::string, JSONValue::ref> ValuesMap;
ValuesMap values = objectValue->getValues();
for (auto & value : values) {
rapidjson::Value obj;
jsonValueToRapidJSON(value.second.get(), obj, document);
rapidjson::Value key;
key.SetString(value.first.c_str(), value.first.size(), document.GetAllocator());
rapidValue.AddMember(key, obj, document.GetAllocator());
}
return;
}
assert(false);
}
/*
* generate from "sync_conf.json": "jos_lib::SyncServerConf"
*/
bool Serialize(const jos_lib::SyncServerConf& obj_val, jos_lib::Allocator& alloc, rapidjson::Value& json_val)
{
do
{
json_val.SetObject();
// fields from "jos_lib::SyncServerConf"
if (!Serialize(obj_val.network, "network", alloc, json_val)) break; // @(field_type : NetworkConf)
if (!Serialize(obj_val.sync, "sync", alloc, json_val)) break; // @(field_type : SyncConf)
return true;
} while (0);
return false;
}
void
Backend::to_json_value(rapidjson::Document& d, rapidjson::Value& v) const
{
rapidjson::Document::AllocatorType& allocator = d.GetAllocator();
v.SetObject();
// Avoid unused variable warnings
(void)allocator;
if (kind_) {
rapidjson::Value v_kind;
v_kind.SetString(*kind_, allocator);
v.AddMember("kind", v_kind, allocator);
}
if (apiVersion_) {
rapidjson::Value v_apiVersion;
v_apiVersion.SetString(*apiVersion_, allocator);
v.AddMember("apiVersion", v_apiVersion, allocator);
}
if (id_) {
rapidjson::Value v_id;
v_id.SetString(*id_, allocator);
v.AddMember("id", v_id, allocator);
}
if (name_) {
rapidjson::Value v_name;
v_name.SetString(*name_, allocator);
v.AddMember("name", v_name, allocator);
}
if (url_) {
rapidjson::Value v_url;
v_url.SetString(*url_, allocator);
v.AddMember("url", v_url, allocator);
}
rapidjson::Value v_services(rapidjson::kArrayType);
v_services.Reserve(services_.size(), allocator);
for (const auto & e : services_) {
rapidjson::Value v(rapidjson::kObjectType);
e->to_json_value(d, v);
v_services.PushBack(v, allocator);
}
v.AddMember("services", v_services, allocator);
}
/*
* generate from "sync_conf.json": "jos_lib::SyncConf"
*/
bool Serialize(const jos_lib::SyncConf& obj_val, jos_lib::Allocator& alloc, rapidjson::Value& json_val)
{
do
{
json_val.SetObject();
// fields from "jos_lib::SyncConf"
if (!Serialize(obj_val.logs_path, "logs_path", alloc, json_val)) break; // @(field_type : std::string)
if (!Serialize(obj_val.ngx_path, "ngx_path", alloc, json_val)) break; // @(field_type : std::string)
if (!Serialize(obj_val.auth_path, "auth_path", alloc, json_val)) break; // @(field_type : std::string)
if (!Serialize(obj_val.threads, "threads", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.release_interval, "release_interval", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.checkdb_interval, "checkdb_interval", alloc, json_val)) break; // @(field_type : int)
if (!Serialize(obj_val.checklog_interval, "checklog_interval", alloc, json_val)) break; // @(field_type : int)
return true;
} while (0);
return false;
}
void jsonValueToRapidJSON(JSONValue* value, rapidjson::Value& rapidValue, rapidjson::Document& document) {
JSONInt* intValue = dynamic_cast<JSONInt*>(value);
if (intValue) {
rapidValue.SetInt(intValue->getValue());
return;
}
JSONString* stringValue = dynamic_cast<JSONString*>(value);
if (stringValue) {
rapidValue.SetString(stringValue->getValue().c_str(), stringValue->getValue().size(), document.GetAllocator());
return;
}
JSONBool* boolValue = dynamic_cast<JSONBool*>(value);
if (boolValue) {
rapidValue.SetBool(boolValue->getValue());
return;
}
JSONArray* arrayValue = dynamic_cast<JSONArray*>(value);
if (arrayValue) {
rapidValue.SetArray();
std::vector<JSONValue::ref> values = arrayValue->getValues();
for (size_t i = 0; i < values.size(); i++) {
rapidjson::Value obj;
jsonValueToRapidJSON(values[i].get(), obj, document);
rapidValue.PushBack(obj, document.GetAllocator());
}
return;
}
JSONObject* objectValue = dynamic_cast<JSONObject*>(value);
if (objectValue) {
rapidValue.SetObject();
typedef std::map<std::string, JSONValue::ref> ValuesMap;
ValuesMap values = objectValue->getValues();
for (ValuesMap::iterator it = values.begin(); it != values.end(); it++) {
rapidjson::Value obj;
jsonValueToRapidJSON(it->second.get(), obj, document);
rapidjson::Value key;
key.SetString(it->first.c_str(), it->first.size(), document.GetAllocator());
rapidValue.AddMember(key, obj, document.GetAllocator());
}
return;
}
assert(false);
}
void
Plan::to_json_value(rapidjson::Document& d, rapidjson::Value& v) const
{
rapidjson::Document::AllocatorType& allocator = d.GetAllocator();
v.SetObject();
// Avoid unused variable warnings
(void)allocator;
if (kind_) {
rapidjson::Value v_kind;
v_kind.SetString(*kind_, allocator);
v.AddMember("kind", v_kind, allocator);
}
if (apiVersion_) {
rapidjson::Value v_apiVersion;
v_apiVersion.SetString(*apiVersion_, allocator);
v.AddMember("apiVersion", v_apiVersion, allocator);
}
if (id_) {
rapidjson::Value v_id;
v_id.SetString(*id_, allocator);
v.AddMember("id", v_id, allocator);
}
if (goal_id_) {
rapidjson::Value v_goal_id;
v_goal_id.SetString(*goal_id_, allocator);
v.AddMember("goal-id", v_goal_id, allocator);
}
if (cost_) {
rapidjson::Value v_cost;
v_cost.SetFloat(*cost_);
v.AddMember("cost", v_cost, allocator);
}
rapidjson::Value v_actions(rapidjson::kArrayType);
v_actions.Reserve(actions_.size(), allocator);
for (const auto & e : actions_) {
rapidjson::Value v(rapidjson::kObjectType);
e->to_json_value(d, v);
v_actions.PushBack(v, allocator);
}
v.AddMember("actions", v_actions, allocator);
}
void xml2json_traverse_node(rapidxml::xml_node<> *xmlnode, rapidjson::Value &jsvalue, rapidjson::Document::AllocatorType& allocator)
{
//cout << "this: " << xmlnode->type() << " name: " << xmlnode->name() << " value: " << xmlnode->value() << endl;
rapidjson::Value jsvalue_chd;
jsvalue.SetObject();
jsvalue_chd.SetObject();
rapidxml::xml_node<> *xmlnode_chd;
// classified discussion:
if((xmlnode->type() == rapidxml::node_data || xmlnode->type() == rapidxml::node_cdata) && xmlnode->value())
{
// case: pure_text
jsvalue.SetString(xmlnode->value(), allocator); // then addmember("#text" , jsvalue, allocator)
}
else if(xmlnode->type() == rapidxml::node_element)
{
if(xmlnode->first_attribute())
{
if(xmlnode->first_node() && xmlnode->first_node()->type() == rapidxml::node_data && count_children(xmlnode) == 1)
{
// case: <e attr="xxx">text</e>
rapidjson::Value jn, jv;
jn.SetString(xml2json_text_additional_name, allocator);
jv.SetString(xmlnode->first_node()->value(), allocator);
jsvalue.AddMember(jn, jv, allocator);
xml2json_add_attributes(xmlnode, jsvalue, allocator);
return;
}
else
{
// case: <e attr="xxx">...</e>
xml2json_add_attributes(xmlnode, jsvalue, allocator);
}
}
else
{
if(!xmlnode->first_node())
{
// case: <e />
jsvalue.SetNull();
return;
}
else if(xmlnode->first_node()->type() == rapidxml::node_data && count_children(xmlnode) == 1)
{
// case: <e>text</e>
if (xml2json_numeric_support == false)
{
jsvalue.SetString(rapidjson::StringRef(xmlnode->first_node()->value()), allocator);
}
else
{
bool hasDecimal;
if (xml2json_has_digits_only(xmlnode->first_node()->value(), &hasDecimal) == false)
{
jsvalue.SetString(rapidjson::StringRef(xmlnode->first_node()->value()), allocator);
}
else
{
char *bgnptr = xmlnode->first_node()->value();
char *endptr = bgnptr;
if (hasDecimal)
{
double value = std::strtod(bgnptr, &endptr);
if (bgnptr != endptr)
jsvalue.SetDouble(value);
else
jsvalue.SetString(rapidjson::StringRef(bgnptr), allocator);
}
else
{
long int value = std::strtol(bgnptr, &endptr, 0);
if (bgnptr != endptr)
jsvalue.SetInt(value);
else
jsvalue.SetString(rapidjson::StringRef(bgnptr), allocator);
}
}
}
return;
}
}
if(xmlnode->first_node())
{
// case: complex else...
std::map<std::string, int> name_count;
for(xmlnode_chd = xmlnode->first_node(); xmlnode_chd; xmlnode_chd = xmlnode_chd->next_sibling())
{
std::string current_name;
const char *name_ptr = NULL;
rapidjson::Value jn, jv;
if(xmlnode_chd->type() == rapidxml::node_data || xmlnode_chd->type() == rapidxml::node_cdata)
{
current_name = xml2json_text_additional_name;
name_count[current_name]++;
jv.SetString(xml2json_text_additional_name, allocator);
name_ptr = jv.GetString();
}
else if(xmlnode_chd->type() == rapidxml::node_element)
{
current_name = xmlnode_chd->name();
name_count[current_name]++;
name_ptr = xmlnode_chd->name();
}
xml2json_traverse_node(xmlnode_chd, jsvalue_chd, allocator);
if(name_count[current_name] > 1 && name_ptr)
xml2json_to_array_form(name_ptr, jsvalue, jsvalue_chd, allocator);
else
{
jn.SetString(name_ptr, allocator);
jsvalue.AddMember(jn, jsvalue_chd, allocator);
}
}
}
}
else
{
std::cerr << "err data!!" << std::endl;
}
}
void ConvertToJSON(const msgpack::object& object, rapidjson::Value& value, rapidjson::MemoryPoolAllocator<>& allocator)
{
switch (object.type)
{
case msgpack::type::BOOLEAN:
value.SetBool(object.as<bool>());
break;
case msgpack::type::POSITIVE_INTEGER:
case msgpack::type::NEGATIVE_INTEGER:
value.SetInt(object.as<int>());
break;
case msgpack::type::FLOAT:
value.SetDouble(object.as<double>());
break;
case msgpack::type::STR:
{
std::string string = object.as<std::string>();
value.SetString(string.c_str(), string.size(), allocator);
break;
}
case msgpack::type::ARRAY:
{
auto list = object.as<std::vector<msgpack::object>>();
value.SetArray();
for (auto& entry : list)
{
rapidjson::Value inValue;
ConvertToJSON(entry, inValue, allocator);
value.PushBack(inValue, allocator);
}
break;
}
case msgpack::type::MAP:
{
auto list = object.as<std::map<std::string, msgpack::object>>();
value.SetObject();
for (auto& entry : list)
{
rapidjson::Value inValue;
ConvertToJSON(entry.second, inValue, allocator);
rapidjson::Value name;
name.SetString(entry.first.c_str(), entry.first.size(), allocator);
value.AddMember(name, inValue, allocator);
}
break;
}
default:
value.SetNull();
break;
}
}
void traverse_node(rapidxml::xml_node<> *xmlnode, rapidjson::Value &jsvalue, rapidjson::Document::AllocatorType& allocator)
{
//cout << "this: " << xmlnode->type() << " name: " << xmlnode->name() << " value: " << xmlnode->value() << endl;
rapidjson::Value jsvalue_chd;
jsvalue.SetObject();
jsvalue_chd.SetObject();
rapidxml::xml_node<> *xmlnode_chd;
// classified discussion:
if ((xmlnode->type() == rapidxml::node_data || xmlnode->type() == rapidxml::node_cdata) && xmlnode->value())
{
// case: pure_text
jsvalue.SetString(xmlnode->value(), allocator); // then addmember("#text" , jsvalue, allocator)
}
else if (xmlnode->type() == rapidxml::node_element)
{
if (xmlnode->first_attribute())
{
if (xmlnode->first_node() && xmlnode->first_node()->type() == rapidxml::node_data && count_children(xmlnode) == 1)
{
// case: <e attr="xxx">text</e>
rapidjson::Value jn, jv;
jn.SetString("#text", allocator);
jv.SetString(xmlnode->first_node()->value(), allocator);
jsvalue.AddMember(jn, jv, allocator);
add_attributes(xmlnode, jsvalue, allocator);
return;
}
else
{
// case: <e attr="xxx">...</e>
add_attributes(xmlnode, jsvalue, allocator);
}
}
else
{
if (!xmlnode->first_node())
{
// case: <e />
jsvalue.SetNull();
return;
}
else if (xmlnode->first_node()->type() == rapidxml::node_data && count_children(xmlnode) == 1)
{
// case: <e>text</e>
jsvalue.SetString(rapidjson::StringRef(xmlnode->first_node()->value()), allocator);
return;
}
}
if (xmlnode->first_node())
{
// case: complex else...
std::map<std::string, int> name_count;
for (xmlnode_chd = xmlnode->first_node(); xmlnode_chd; xmlnode_chd = xmlnode_chd->next_sibling())
{
std::string current_name;
const char *name_ptr = NULL;
rapidjson::Value jn, jv;
if (xmlnode_chd->type() == rapidxml::node_data || xmlnode_chd->type() == rapidxml::node_cdata)
{
current_name = "#text";
name_count[current_name]++;
jv.SetString("#text", allocator);
name_ptr = jv.GetString();
}
else if (xmlnode_chd->type() == rapidxml::node_element)
{
current_name = xmlnode_chd->name();
name_count[current_name]++;
name_ptr = xmlnode_chd->name();
}
traverse_node(xmlnode_chd, jsvalue_chd, allocator);
if (name_count[current_name] > 1 && name_ptr)
to_array_form(name_ptr, jsvalue, jsvalue_chd, allocator);
else
{
jn.SetString(name_ptr, allocator);
jsvalue.AddMember(jn, jsvalue_chd, allocator);
}
}
}
}
else
{
std::cerr << "err data!!" << std::endl;
}
}
static void ToRapidjsonValue(rapidjson::Value& rapidjsonValue, const JSONValue& jsonValue, rapidjson::MemoryPoolAllocator<>& allocator)
{
switch (jsonValue.GetValueType())
{
case JSON_NULL:
rapidjsonValue.SetNull();
break;
case JSON_BOOL:
rapidjsonValue.SetBool(jsonValue.GetBool());
break;
case JSON_NUMBER:
{
switch (jsonValue.GetNumberType())
{
case JSONNT_INT:
rapidjsonValue.SetInt(jsonValue.GetInt());
break;
case JSONNT_UINT:
rapidjsonValue.SetUint(jsonValue.GetUInt());
break;
default:
rapidjsonValue.SetDouble(jsonValue.GetDouble());
break;
}
}
break;
case JSON_STRING:
rapidjsonValue.SetString(jsonValue.GetCString(), allocator);
break;
case JSON_ARRAY:
{
const JSONArray& jsonArray = jsonValue.GetArray();
rapidjsonValue.SetArray();
rapidjsonValue.Reserve(jsonArray.Size(), allocator);
for (unsigned i = 0; i < jsonArray.Size(); ++i)
{
rapidjson::Value value;
rapidjsonValue.PushBack(value, allocator);
ToRapidjsonValue(rapidjsonValue[i], jsonArray[i], allocator);
}
}
break;
case JSON_OBJECT:
{
const JSONObject& jsonObject = jsonValue.GetObject();
rapidjsonValue.SetObject();
for (JSONObject::ConstIterator i = jsonObject.Begin(); i != jsonObject.End(); ++i)
{
const char* name = i->first_.CString();
rapidjson::Value value;
rapidjsonValue.AddMember(name, value, allocator);
ToRapidjsonValue(rapidjsonValue[name], i->second_, allocator);
}
}
break;
default:
break;
}
}
void jsonifyModuleType(const ModuleType& moduleType, rapidjson::Value& moduleTypeValue, rapidjson::Document& document){
//TODO assert moduleType.isComposite
moduleTypeValue.SetObject();
moduleTypeValue.AddMember("name", moduleType.getName().c_str(), document.GetAllocator());
moduleTypeValue.AddMember("description", moduleType.getDescription().c_str(), document.GetAllocator());
//handle inputs
rapidjson::Value inputs;
inputs.SetArray();
for(unsigned int i=0; i<moduleType.numInputs(); ++i){
const ModuleInput* input = moduleType.getInput(i);
rapidjson::Value inputValue;
inputValue.SetObject();
inputValue.AddMember("name", input->getName().c_str(), document.GetAllocator());
int dimensionality = input->getSignalType().dimensionality;
std::stringstream ss;
ss << dimensionality << "f";
rapidjson::Value typeValue(ss.str().c_str(), document.GetAllocator());
inputValue.AddMember("type", typeValue, document.GetAllocator());
inputs.PushBack(inputValue, document.GetAllocator());
}
moduleTypeValue.AddMember("inputs", inputs, document.GetAllocator());
//handle outputs
rapidjson::Value outputs;
outputs.SetArray();
for(unsigned int i=0; i<moduleType.numOutputs(); ++i){
const ModuleOutput* output = moduleType.getOutput(i);
const Module* outputsModule = moduleType.getGraph()->getModule("outputs");
rapidjson::Value outputValue;
outputValue.SetObject();
outputValue.AddMember("name", output->getName().c_str(), document.GetAllocator());
auto inputLink = outputsModule->getInput(i);
auto outputLink = outputsModule->getInput(i)->getOutputLink();
if(outputLink!=nullptr){
std::string sourceString = outputLink->getOwner().getName() + "." + outputLink->getModuleOutput().getName();
rapidjson::Value sourceStringValue(sourceString.c_str(),document.GetAllocator());
outputValue.AddMember("source", sourceStringValue, document.GetAllocator());
} else {
rapidjson::Value vectorValue;
vectorValue.SetArray();
auto unlinkedValue = inputLink->getUnlinkedValue();
for(int j=0; j<unlinkedValue.getSignalType().dimensionality; ++j){
vectorValue.PushBack(unlinkedValue[j], document.GetAllocator());
}
outputValue.AddMember("source", vectorValue, document.GetAllocator());
}
outputs.PushBack(outputValue, document.GetAllocator());
}
moduleTypeValue.AddMember("outputs", outputs, document.GetAllocator());
//handle internal modules
rapidjson::Value modulesValue;
modulesValue.SetArray();
auto graph = moduleType.getGraph();
graph->traverseModulesTopological([&](const Module& module){
//skip input/output modules
if(module.getType().isGraphInput() || module.getType().isGraphOutput())return;
rapidjson::Value moduleValue;
jsonifyModule(module, moduleValue, document);
modulesValue.PushBack(moduleValue, document.GetAllocator());
});
moduleTypeValue.AddMember("modules", modulesValue, document.GetAllocator());
}
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;
}
bool clone_value(rapidjson::Value & output, const rapidjson::Value & input, rapidjson::Value::AllocatorType & allocator)
{
if(&output == &input)
{
return false;
}
if(input.IsNull())
{
output.SetNull();
}
else if(input.IsInt64())
{
output.SetInt(input.GetInt64());
}
else if(input.IsInt())
{
output.SetInt(input.GetInt());
}
else if(input.IsDouble())
{
output.SetDouble(input.GetDouble());
}
else if(input.IsBool())
{
output.SetBool(input.GetBool());
}
else if(input.IsString())
{
output.SetString(input.GetString(), input.GetStringLength(), allocator);
}
else if(input.IsArray())
{
rapidjson::Value temp;
output.SetArray();
output.Reserve(input.Size(), allocator);
for(rapidjson::SizeType i = 0; i < input.Size(); ++i)
{
clone_value(temp, input[i], allocator);
output.PushBack(temp, allocator);
}
}
else if(input.IsObject())
{
output.SetObject();
rapidjson::Value key, val;
for(rapidjson::Value::ConstMemberIterator it = input.MemberBegin();
it != input.MemberEnd(); ++it)
{
clone_value(key, it->name, allocator);
clone_value(val, it->value, allocator);
output.AddMember(key, val, allocator);
}
}
else
{
assert(false && "shuldn't execute to here.");
return false;
}
return true;
}
static void
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.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), root.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, root);
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);
pyobj2doc(elm, _v, root);
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)) {
pyobj2doc_pair(key, value, doc, root);
}
}
else {
// TODO: error handle
}
}
void tvalue2json(rapidjson::Value & output, const QVariant & input, rapidjson::Value::AllocatorType & allocator)
{
switch(input.type())
{
case QVariant::Invalid:
{
output.SetNull();
break;
}
case QVariant::Bool:
{
output.SetBool(input.toBool());
break;
}
case QVariant::Int:
{
output.SetInt64(input.toInt());
break;
}
case QVariant::LongLong:
{
output.SetInt64(input.toLongLong());
break;
}
case QVariant::Double:
{
output.SetDouble(input.toDouble());
break;
}
case QVariant::String:
{
QByteArray str = input.toString().toUtf8();
output.SetString(str.data(), str.size(), allocator);
break;
}
case QVariant::StringList:
{
QStringList list = input.toStringList();
output.SetArray();
output.Reserve(list.size(), allocator);
rapidjson::Value temp;
for(QStringList::const_iterator it = list.begin(); it != list.end(); ++it)
{
QByteArray str = it->toUtf8();
temp.SetString(str.data(), str.size(), allocator);
output.PushBack(temp, allocator);
}
break;
}
case QVariant::List:
{
QList<QVariant> list = input.toList();
output.SetArray();
output.Reserve(list.size(), allocator);
rapidjson::Value temp;
for(QList<QVariant>::const_iterator it = list.begin(); it != list.end(); ++it)
{
tvalue2json(temp, *it, allocator);
output.PushBack(temp, allocator);
}
break;
}
case QVariant::Map:
{
output.SetObject();
rapidjson::Value tempK, tempV;
QMap<QString, QVariant> qmap = input.toMap();
for(QMap<QString, QVariant>::const_iterator it = qmap.begin(); it != qmap.end(); ++it)
{
tvalue2json(tempK, it.key(), allocator);
tvalue2json(tempV, it.value(), allocator);
output.AddMember(tempK, tempV, allocator);
}
break;
}
case QVariant::Point:
{
QPoint pt = input.toPoint();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
break;
}
case QVariant::PointF:
{
QPointF pt = input.toPointF();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
break;
}
case QVariant::Size:
{
QSize pt = input.toSize();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::SizeF:
{
QSizeF pt = input.toSizeF();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::Rect:
{
QRect pt = input.toRect();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::RectF:
{
QRectF pt = input.toRectF();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::Vector2D:
{
QVector2D pt = input.value<QVector2D>();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
break;
}
case QVariant::Vector3D:
{
QVector3D pt = input.value<QVector3D>();
output.SetArray();
output.Reserve(3, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.z(), allocator);
break;
}
case QVariant::Vector4D:
{
QVector4D pt = input.value<QVector4D>();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.z(), allocator);
output.PushBack(pt.w(), allocator);
break;
}
case QVariant::Color:
{
QColor pt = input.value<QColor>();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.red(), allocator);
output.PushBack(pt.green(), allocator);
output.PushBack(pt.blue(), allocator);
output.PushBack(pt.alpha(), allocator);
break;
}
default:
{
output.SetNull();
assert(false && "shuldn't execute to here.");
}
}
}