void from_json(const json& j, ToolConfig& a) {
std::vector<std::string>& files = a.getSourceFiles();
try {
files = j.at("source_files").get<std::vector<std::string>>();
} catch (...) {
files = {};
}
try {
a.setExecutable(j.at("executable"));
} catch (...) {
a.setExecutable("");
}
try {
a.setToolID(j.at("tool_id"));
} catch (...) {
a.setToolID("None");
}
try {
a.setVersion(j.at("version"));
} catch (...) {
a.setVersion(newVersion);
}
std::vector<ToolAction>& actions = a.getActions();
try {
actions = j.at("actions").get<std::vector<ToolAction>>();
} catch (...) {
actions = {};
}
}
fostlib::headers_base::content::content(
const json &values, const string &root
) {
try {
if ( values.isobject() ) {
for ( json::const_iterator item(values.begin()); item != values.end(); ++item ) {
const auto key = coerce<string>(item.key());
const auto itemstr = coerce<string>(*item);
if ( key == root ) {
value(itemstr);
} else {
m_subvalues[key] = itemstr;
}
}
} else if ( values.isatom() ) {
value(coerce<string>(values));
} else {
throw exceptions::not_implemented(__func__,
"Can't set header values from this JSON", values);
}
} catch ( exceptions::exception &e ) {
insert(e.data(), "headers_base", "content", "values", values);
insert(e.data(), "headers_base", "content", "root", root);
throw;
}
}
void read_message(int clientID, string message){
// Deserialize message from the string
json msg = json::parse(message);
if (msg["MESSAGE_TYPE"] == "CLIENT_UPDATE") {
// Send a time stamp reply for client-side latency estimation
json tStamps;
tStamps["MESSAGE_TYPE"] = "TIME_STAMP_REPLY";
tStamps["T2"] = chrono::system_clock::now().time_since_epoch() / chrono::milliseconds(1); // Time received
tStamps["T1"] = msg["TIME_STAMP"]; // Origination time
send_message(clientID, tStamps);
// Now, process the client update:
// Scenario A: We don't have a game ready yet. This is a pre-game message.
if (game_p == NULL) {
// Step 1: Put the message in the correct bin.
pregame_player_msgs[clientID] = msg;
// Step 2: If both bins are filled (2 players ready),
// then start a new game.
if (pregame_player_msgs.size() == 2) {
game_p = new SnakeGame(pregame_player_msgs[0], pregame_player_msgs[1]);
pregame_player_msgs.clear();
}
}
// Scenario B: A game already exists. Just forward the message to it.
else {
game_p->handleClientInput(msg);
}
}
}
json merge(const json &a, const json &b) {
json result = a.flatten();
json tmp = b.flatten();
for ( auto it = tmp.begin(); it != tmp.end(); ++it )
result[it.key()] = it.value();
return result.unflatten();
}
int upload_file(const char * from, const char * id, const char * to, char * new_id, size_t id_sz, CheckSum & md5) {
fprintf(rlog, "uploading %s%s -> %s\n", id ? "id: " : "", id ? id : from, to);
auto src = fopen(from, "r");
if (!src) {
fprintf(rlog, "ERROR: could not open \"%s\" for reading\n", from);
return -1;
}
char url[1024];
snprintf(url, 1024, "upload/drive/v3/files%s%s?uploadType=resumable&fields=name,id,size,md5Checksum",
id ? "/" : "", id ? id : "");
DriveApi upload{id ? PATCH : POST, url};
upload.headers.push_back("X-Upload-Content-Type: application/octet-stream");
struct stat st = {};
stat(from, &st);
if (!id)
upload.params.AddMember("parents", Value().SetArray().PushBack(StringRef(root_id), upload.params.doc.GetAllocator()));
if (to)
upload.params.AddMember("name", StringRef(to));
char date[32];
strftime(date, 32, "%Y-%m-%dT%TZ", gmtime(&st.st_mtime));
upload.params.AddMember("modifiedTime", StringRef(date));
upload.include_headers = true;
auto resp = upload.perform();
if (report_error("upload step 1", resp) != 0) {
fclose(src);
return -1;
}
//printf("Success\n");
//printf("%s\n", resp.str.c_str());
auto location = get_http_header("Location", resp.str.c_str());
DriveApi put{PUT, location.c_str()};
put.headers.push_back("Content-Type: application/octet-stream");
put.body_fh = src;
resp = put.perform();
fclose(src);
HANDLE_ERROR("upload step 2", resp);
md5 = resp.data["md5Checksum"].GetString();
//printf("Upload Success\n");
//printf("%s\n", resp.str.c_str());
///return {resp.data["id"].asString(), atoi(resp.data["size"].asCString()), resp.data["md5Checksum"].asString()};
if (new_id)
strncpy(new_id, resp.data["id"].GetString(), id_sz);
return 0;
}
void from_json(const json &j, AtomData &a) {
if (j.is_object()==false || j.size()!=1)
throw std::runtime_error("Invalid JSON data for AtomData");
for (auto it : j.items()) {
a.name = it.key();
auto& val = it.value();
a.activity = val.value("activity", a.activity) * 1.0_molar;
a.alphax = val.value("alphax", a.alphax);
a.charge = val.value("q", a.charge);
a.dp = val.value("dp", a.dp) * 1.0_angstrom;
a.dprot = val.value("dprot", a.dprot) * 1.0_rad;
a.eps = val.value("eps", a.eps) * 1.0_kJmol;
a.id() = val.value("id", a.id());
a.mu = val.value("mu", a.mu);
a.mulen = val.value("mulen", a.mulen);
a.scdir = val.value("scdir", a.scdir);
a.sclen = val.value("sclen", a.sclen);
a.mw = val.value("mw", a.mw);
a.sigma = val.value("sigma", 0.0) * 1.0_angstrom;
if (fabs(a.sigma)<1e-20)
a.sigma = 2.0*val.value("r", 0.0) * 1.0_angstrom;
a.tension = val.value("tension", a.tension) * 1.0_kJmol / (1.0_angstrom*1.0_angstrom);
a.tfe = val.value("tfe", a.tfe) * 1.0_kJmol / (1.0_angstrom*1.0_angstrom*1.0_molar);
a.hydrophobic = val.value("hydrophobic", false);
}
}
void Colour::fromJSON(json& jvalue)
{
//Will accept integer colour or [r,g,b,a] array or
// string containing x11 name or hex #rrggbb or html rgba(r,g,b,a)
if (jvalue.is_number())
{
value = jvalue;
}
else if (jvalue.is_array())
{
float R = jvalue[0];
float G = jvalue[1];
float B = jvalue[2];
float A = 1.0;
if (jvalue.size() > 3) A = jvalue[3];
if (R <= 1.0 && G <= 1.0 && B <= 1.0 && A <= 1.0)
{
r = R*255.0;
g = G*255.0;
b = B*255.0;
a = A*255.0;
}
else
{
r = R;
g = G;
b = B;
}
}
else if (jvalue.is_string())
{
fromString(jvalue);
}
//std::cout << "COLOUR: " << std::setw(2) << jvalue << " ==> " << *this << std::endl;
}
void LogEntryRootFilter::parseJson(const json &j) {
auto filterType_json = j.find("filterType");
if (filterType_json != j.end()) {
filterType = (FilterType) filterType_json->get<int>();
} else {
filterType = filterIn;
}
}
void JsonUtil::ensureType(const string& aFieldName, const json& aNew, const json& aExisting) {
if (aExisting.is_number()) {
if (!aNew.is_number()) {
throwError(aFieldName, ERROR_INVALID, "The new value must be a number");
}
} else if (aNew.type() != aExisting.type()) {
throwError(aFieldName, ERROR_INVALID, "Type of the new value doesn't match with the existing type");
}
}
QM_NAMESPACE
boost::python::dict to_dict(json const& self) {
boost::python::dict d;
for(json::const_iterator it=self.begin();it!=self.end();++it) {
d[it->first] = it->second;
}
return d;
}
std::shared_ptr<dariadb::MeasArray>
read_meas_array(const dariadb::scheme::IScheme_Ptr &scheme, const json &js) {
auto result = std::make_shared<dariadb::MeasArray>();
auto js_iter = js.find("append_values");
if (js_iter == js.end()) {
dariadb::logger_fatal("append_values not found");
return nullptr;
}
auto values = *js_iter;
for (auto it = values.begin(); it != values.end(); ++it) {
dariadb::MeasArray sub_result;
auto id_str = it.key();
auto val4id = it.value();
dariadb::Id id = scheme->addParam(id_str);
auto flag_js = val4id["F"];
auto val_js = val4id["V"];
auto time_js = val4id["T"];
if (flag_js.size() != val_js.size() || time_js.size() != val_js.size()) {
THROW_EXCEPTION("bad query format, flags:", flag_js.size(),
" values:", val_js.size(), " times:", time_js.size(),
" query: ", js.dump(1));
}
sub_result.resize(flag_js.size());
size_t pos = 0;
for (auto f_it = flag_js.begin(); f_it != flag_js.end(); ++f_it) {
dariadb::Flag f = *f_it;
sub_result[pos++].flag = f;
}
pos = 0;
for (auto v_it = val_js.begin(); v_it != val_js.end(); ++v_it) {
dariadb::Value v = *v_it;
sub_result[pos++].value = v;
}
pos = 0;
for (auto t_it = time_js.begin(); t_it != time_js.end(); ++t_it) {
dariadb::Time t = *t_it;
sub_result[pos++].time = t;
}
dariadb::logger("in query ", sub_result.size(), " values for id:", id);
for (auto v : sub_result) {
v.id = id;
result->push_back(v);
}
}
return result;
}
RenderableSpriteBlueprint::RenderableSpriteBlueprint(json& j) {
if (j.count("diffuse")) {
_diffuse = j["diffuse"].get<std::string>();
}
if (j.count("normal")) {
_normal = j["normal"].get<std::string>();
}
if (j.count("lit")) {
_lit = j["lit"].get<bool>();
}
}
json JsonUtil::filterExactValues(const json& aNew, const json& aCompareTo) noexcept {
json ret = aNew;
for (const auto& v: json::iterator_wrapper(aCompareTo)) {
auto key = v.key();
auto i = aNew.find(key);
if (i != aNew.end() && aNew.at(key) == aCompareTo.at(key)) {
ret.erase(key);
}
}
return ret;
}
optional<int> FavoriteHubUtils::deserializeIntHubSetting(const string& aFieldName, const json& aJson) {
auto p = aJson.find(aFieldName);
if (p == aJson.end()) {
return boost::none;
}
if ((*p).is_null()) {
return HUB_SETTING_DEFAULT_INT;
}
return JsonUtil::parseValue<int>(aFieldName, *p);
}
bool RPCMethod::ValidateArguments(json j) {
if (j.size() != this->paramTypes->size()) {
return false;
}
for (unsigned int c = 0; c < this->paramTypes->size(); c++) {
if (!this->checkType(this->paramTypes->at(c), j.at(c))) {
return false;
}
}
return true;
}
RenderableBackgroundBlueprint::RenderableBackgroundBlueprint(json& j) {
if (j.count("diffuse")) {
_diffuse = j["diffuse"].get<std::string>();
}
if (j.count("normal")) {
_normal = j["normal"].get<std::string>();
}
if (j.count("scale")) {
_scale = j["scale"].get<float>();
} else {
_scale = 1;
}
}
LightBlueprint::LightBlueprint(json& j) {
_type = j["type"];
if (j.count("x")) _x = j["x"].get<float>();
if (j.count("y")) _y = j["y"].get<float>();
if (j.count("z")) _z = j["z"].get<float>();
if (j.count("drop")) _drop = j["drop"].get<float>();
if (j.count("end")) _end = j["end"].get<float>();
if (j.count("depth")) _depth = j["depth"].get<float>();
if (j.count("color")) {
_color = Color(j["color"][0], j["color"][1], j["color"][2]);
}
}
void Movebase::from_json(const json &j) {
auto it = j.find("repeat");
if (it!=j.end()) {
if (it->is_number())
repeat = it->get<double>();
else
if (it->is_string())
if (it->get<std::string>()=="N")
repeat = -1;
}
_from_json(j);
if (repeat<0)
repeat=0;
}
bool RPCMethod::checkType(ParamType type, json j) {
switch (type) {
case ParamType::Bool:
return j.is_boolean();
case ParamType::Int:
return j.is_number_integer();
case ParamType::Float:
return j.is_number();
case ParamType::String:
return j.is_string();
case ParamType::JSON:
return true;
}
}
double value_inf(const json &j, const std::string &key) {
auto it = j.find(key);
if (it==j.end())
throw std::runtime_error("unknown json key '" + key + "'");
else
if (it->is_string()) {
if (*it=="inf")
return std::numeric_limits<double>::infinity();
if (*it=="-inf")
return -std::numeric_limits<double>::infinity();
throw std::runtime_error("value must be number or 'inf'");
}
return double(*it);
}
static void GenStat(Stat& stat, const json& v) {
switch (v.type()) {
case value_types::array_t:
for (json::const_array_iterator itr = v.begin_elements(); itr != v.end_elements(); ++itr)
GenStat(stat, *itr);
stat.arrayCount++;
stat.elementCount += v.size();
break;
case value_types::empty_object_t:
case value_types::object_t:
for (json::const_object_iterator itr = v.begin_members(); itr != v.end_members(); ++itr) {
GenStat(stat, itr->value());
stat.stringLength += itr->name().size();
}
stat.objectCount++;
stat.memberCount += v.size();
stat.stringCount += v.size();
break;
case value_types::string_t:
stat.stringCount++;
stat.stringLength += v.as_string().size();
break;
case value_types::small_string_t:
stat.stringCount++;
stat.stringLength += v.as_string().size();
break;
case value_types::double_t:
case value_types::integer_t:
case value_types::uinteger_t:
stat.numberCount++;
break;
case value_types::bool_t:
if (v.as_bool())
stat.trueCount++;
else
stat.falseCount++;
break;
case value_types::null_t:
stat.nullCount++;
break;
}
}
linear_diffusion::linear_diffusion(json const& material_data) : material_property(material_data)
{
if (material_data.find("conductivity") != material_data.end())
{
m_conductivity = material_data["conductivity"];
}
if (material_data.find("specific_heat") != material_data.end())
{
m_specific_heat = material_data["specific_heat"];
}
else
{
throw std::domain_error("\"specific_heat\" needs to be specified as a material "
"property");
}
}
static void iter_convert(const json& json, string& root_path, datum& ret_datum) {
json_value* value = json.get();
if (typeid(*value) == typeid(json_integer)) {
json_integer* int_value = dynamic_cast<json_integer*>(value);
convert_integer(*int_value, root_path, ret_datum);
} else if (typeid(*value) == typeid(json_float)) {
json_float* float_value = dynamic_cast<json_float*>(value);
convert_float(*float_value, root_path, ret_datum);
} else if (typeid(*value) == typeid(json_string)) {
json_string* string_value = dynamic_cast<json_string*>(value);
convert_string(*string_value, root_path, ret_datum);
} else if (typeid(*value) == typeid(json_bool)) {
json_bool* bool_value = dynamic_cast<json_bool*>(value);
convert_bool(*bool_value, root_path, ret_datum);
} else if (typeid(*value) == typeid(json_null)) {
json_null* null_value = dynamic_cast<json_null*>(value);
convert_null(*null_value, root_path, ret_datum);
} else if (typeid(*value) == typeid(json_array)) {
json_array* array_value = dynamic_cast<json_array*>(value);
convert_array(*array_value, root_path, ret_datum);
} else if (typeid(*value) == typeid(json_object)) {
json_object* object_value = dynamic_cast<json_object*>(value);
convert_object(*object_value, root_path, ret_datum);
}
}
json HTTPHandler::postAPIRequest(json data, const char *url)
{
CURL *curl;
CURLcode res;
string response, send_data;
ostringstream auth_header, content_header;
struct curl_slist *chunk = NULL;
curl = curl_easy_init();
json j = {};
send_data = data.dump();
if (curl)
{
auth_header << "Authorization: Bearer " << Config::getAuthToken().c_str();
content_header << "Content-Type: application/json";
chunk = curl_slist_append(chunk, auth_header.str().c_str());
chunk = curl_slist_append(chunk, content_header.str().c_str());
res = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, send_data.c_str());
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeToString);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
j = json::parse(response);
}
return j;
}
InputContext::InputContext( const json & j )
{
_name = j.get( "context", json::nullRef ).asString();
_priority = j.get( "priority", json::nullRef ).asInt();
auto inputList = j.get( "input_list", json::nullRef );
if( inputList.isNull() )
{
TRACE_WARNING( "Input Context action list is not found." );
return;
}
for( uint i = 0; i < inputList.size(); ++i )
{
addEventAction( EventAction::FromJson( inputList[ i ] ) );
}
}
bool SimpleScene::Deserialize(const json &node, std::string dir) {
//No camera deserialization for now
if (node.find("layers") == node.end()) {
SIMPLE_LOG("Couldn't deserialize layers");
return false;
}
for (auto l : node["layers"]) {
SimpleLayer* layer = new SimpleLayer();
if (!layer->Deserialize(l))
return false;
AddLayer(layer);
}
return true;
}
Germline::Germline(string code, char shortcut, string path, json json_recom, int max_indexing)
{
int delta_min = -10;
if (json_recom.find("4") != json_recom.end()) {
delta_min = 0;
}
init(code, shortcut, delta_min, max_indexing);
bool regular = (code.find("+") == string::npos);
rep_5 = Fasta(2, "|", regular ? CYS104_IN_GAPPED_V : 0) ;
rep_4 = Fasta(2, "|") ;
rep_3 = Fasta(2, "|", regular ? PHE118_TRP118_IN_GAPPED_J : 0) ;
for (json::iterator it = json_recom["5"].begin();
it != json_recom["5"].end(); ++it)
{
string filename = *it;
f_reps_5.push_back(path + filename);
rep_5.add(path + filename);
}
if (json_recom.find("4") != json_recom.end()) {
for (json::iterator it = json_recom["4"].begin();
it != json_recom["4"].end(); ++it)
{
string filename = *it;
f_reps_4.push_back(path + filename);
rep_4.add(path + filename);
}
}
for (json::iterator it = json_recom["3"].begin();
it != json_recom["3"].end(); ++it)
{
string filename = *it;
f_reps_3.push_back(path + filename);
rep_3.add(path + filename);
}
if (rep_4.size())
seg_method = SEG_METHOD_543 ;
}
void resetGame() {
delete game_p;
game_p = NULL;
pregame_player_msgs.clear();
send_buffer.clear();
receive_buffer.clear();
lastUpdateTime = 0;
}
boost::any configuration_parser::convert_json(const json& _json)
{
switch (_json.type()) {
case json::value_t::string:
return _json.get<std::string>();
case json::value_t::number_float:
return _json.get<double>();
case json::value_t::number_integer:
case json::value_t::number_unsigned:
return _json.get<int>();
case json::value_t::boolean:
return _json.get<bool>();
case json::value_t::array: {
std::vector<boost::any> array;
for (auto&& jj : _json) {
array.push_back(convert_json(jj));
}
return array;
}
case json::value_t::object: {
std::unordered_map<std::string, boost::any> object;
//for (auto&& [k, v] : j.items()) { // Supported in later versions :(
for (auto it = std::begin(_json); it != std::end(_json); ++it) {
object.insert({it.key(), convert_json(it.value())});
}
return object;
}
case json::value_t::null:
return std::string{"NULL"};
default:
const auto type = static_cast<std::uint8_t>(_json.type());
THROW(-1, (boost::format("unhandled type in json_typeof: %d") % type));
}
} // parse_json_object
int rename_file(const char * id, const char * to, time_t mtime) {
fprintf(rlog, "renaming id:%s -> %s\n", id, to);
char url[1024];
snprintf(url, 1024, "drive/v3/files/%s?fields=name,id,size,md5Checksum", id);
DriveApi rename{PATCH, url};
rename.params.AddMember("name", StringRef(to));
char date[32];
strftime(date, 32, "%Y-%m-%dT%TZ", gmtime(&mtime));
rename.params.AddMember("modifiedTime", StringRef(date));
auto resp = rename.perform();
HANDLE_ERROR("rename", resp);
//printf("Rename Success!\n");
//printf("%s\n", resp.str.c_str());
return 0;
}
