void refreshMenu()
{
place_wnames_.clear();
picojson::object& obj = json_.value().get<picojson::object>();
std::size_t num = (start_ + disp_num_) < place_names_.size() ? disp_num_ : place_names_.size() - start_;
for (std::size_t i = 0; i < num; ++i)
{
std::string name = place_names_[start_ + i];
picojson::object& params = obj[name].get<picojson::object>();
char a = 'a' + i;
std::stringstream sstr;
sstr << a << ". " << localize_.get(params["name"].get<std::string>());
place_wnames_.push_back(sstr.str());
}
}
void listup(const int mode, const int level)
{
place_names_.clear();
picojson::object& obj = json_.value().get<picojson::object>();
std::string& type = place_type_[mode];
for (picojson::object::iterator it = obj.begin(); it != obj.end(); ++it)
{
picojson::object& data = (it->second).get<picojson::object>();
std::string& t = data["type"].get<std::string>();
int l = data["level"].get<double>();
bool same_type = (mode == 0) || (t == type);
bool same_level = (level == -1) || (l == level);
if (same_type && same_level) place_names_.push_back(it->first);
}
// TIPS: mapはsort済み
}
SpaceStationType::SpaceStationType(const std::string &id_, const std::string &path_)
: id(id_)
, model(0)
, modelName("")
, angVel(0.f)
, dockMethod(SURFACE)
, numDockingPorts(0)
, numDockingStages(0)
, numUndockStages(0)
, shipLaunchStage(3)
, parkingDistance(0)
, parkingGapSize(0)
{
Json data = JsonUtils::LoadJsonDataFile(path_);
if (data.is_null()) {
Output("couldn't read station def '%s'\n", path_.c_str());
throw StationTypeLoadError();
}
modelName = data.value("model", "");
const std::string type = data.value("type", "");
if (type == "surface")
dockMethod = SURFACE;
else if (type == "orbital")
dockMethod = ORBITAL;
else {
Output("couldn't parse station def '%s': unknown type '%s'\n", path_.c_str(), type.c_str());
throw StationTypeLoadError();
}
angVel = data.value("angular_velocity", 0.0f);
parkingDistance = data.value("parking_distance", 0.0f);
parkingGapSize = data.value("parking_gap_size", 0.0f);
padOffset = data.value("pad_offset", 150.f);
model = Pi::FindModel(modelName, /* allowPlaceholder = */ false);
if (!model) {
Output("couldn't initialize station type '%s' because the corresponding model ('%s') could not be found.\n", path_.c_str(), modelName.c_str());
throw StationTypeLoadError();
}
OnSetupComplete();
}
static void _json_to_lua(lua_State *l, const Json &data)
{
LUA_DEBUG_START(l);
switch (data.type()) {
case Json::nullValue:
lua_pushnil(l);
break;
case Json::intValue:
case Json::uintValue:
case Json::realValue:
lua_pushnumber(l, data.asDouble());
break;
case Json::stringValue: {
const std::string &str(data.asString());
lua_pushlstring(l, str.c_str(), str.size());
break;
}
case Json::booleanValue:
lua_pushboolean(l, data.asBool());
break;
case Json::arrayValue: {
lua_newtable(l);
for (int i = 0; i < int(data.size()); i++) {
lua_pushinteger(l, i+1);
_json_to_lua(l, data[i]);
lua_rawset(l, -3);
}
break;
}
case Json::objectValue: {
lua_newtable(l);
for (Json::const_iterator i = data.begin(); i != data.end(); ++i) {
const std::string &key(i.key().asString());
lua_pushlstring(l, key.c_str(), key.size());
_json_to_lua(l, *i);
lua_rawset(l, -3);
}
break;
}
}
LUA_DEBUG_END(l, 1);
}
/* Convert login information from string to standard json {id, name, site}.
* (original information can be different for different sites).
*/
Json
parse_login_data(const string & juser) {
/* convert string to json */
Json root = Json::load_string(juser);
/* if loginza returned an error - throw it */
if (!root.get("error_message").is_null())
throw Exc() << juser;
/* get identity field */
std::string identity = root["identity"].as_string();
if (identity == "") throw Err() << "login error";
/* default name */
std::string name = identity;
/* extract site */
std::string site = get_site(identity);
/* parse the name if possible and make correct full name */
Json nn = root["name"];
if (nn.is_object()) {
string n1 = nn["first_name"].as_string();
string n2 = nn["last_name"].as_string();
string n3 = nn["full_name"].as_string();
if (n3!="") name=n3;
else if (n1!="" && n2!="") name = n1+" "+n2;
else if (n2!="") name=n2;
else if (n1!="") name=n1;
}
/* lj has only identity */
if (site == "lj") {
size_t i1 = identity.find("http://");
size_t i2 = identity.find(".livejournal.com");
name = identity.substr(i1+7, i2-i1-7);
}
/* build the output json */
Json ret = Json::object();
ret.set("id", Json(identity));
ret.set("site", Json(site));
ret.set("name", Json(name));
return ret;
}
int main(int argc, char** argv) {
if (argc != 2) {
cout << "Usage: clison filename.json\n";
return 1;
}
try {
#ifdef WITH_SCHEMA
ifstream schfs("schema.json");
if (!schfs)
cout << "note: schema.json not found\n";
else {
//meta = Json(schfs);
schfs >> meta;
string schema_url = "http://json-schema.org/draft-04/schema#";
if (meta.type() != Json::OBJECT || meta["$schema"] != schema_url) {
cout << "schema.json is not a http://json-schema.org/draft-04/schema\n";
meta = Json::null;
}
schfs.close();
sprops = meta["properties"];
}
#endif
ifstream fs(argv[1]);
Json js(fs);
fs.close();
Json::indent = 2;
vector<string> path;
cli(js, js, path);
} catch (Json::use_error& ex) {
cout << "use_error: " << ex.what() << '\n';
} catch (Json::parse_error& ex) {
cout << "parse_error: " << ex.what() << '\n';
cout << "line: " << ex.line << ", col: " << ex.col << '\n';
} catch (std::exception& ex) {
cout << "exception: " << ex.what() << '\n';
}
#ifdef TEST
meta = Json::null;
schema = Json::null;
Json::test();
#endif
}
Json RiotService::GetMatchFeedByIds::internalCall() {
Json summoners = _service->_api.getSummonerByIds(_params["ids"]);
Json::object diff;
Json::array matches;
std::string err;
auto cmp = [](const Json & a, const Json & b) {
return a["createDate"].number_value() > b["createDate"].number_value();
};
for (auto & kv : summoners.object_items()) {
Json cache = _service->getSummonerInfoCache(kv.first);
printf("cache : %s\nnew: %s", cache.dump().c_str(), kv.second.dump().c_str());
if (cache.is_null() || cache["revisionDate"].number_value() < kv.second["revisionDate"].number_value()) {
diff[kv.first] = kv.second;
} else {
matches.insert(matches.end(), cache["games"].array_items().begin(), cache["games"].array_items().end());
}
}
std::sort(matches.begin(), matches.end(), cmp);
if (!matches.empty()) {
_onRead(matches);
}
for (auto & kv : diff) {
auto future = std::async(std::launch::async, [this, kv, cmp, &matches]() {
Json newInfo = _service->_api.getRecentGamesBySummonerId(kv.first);
if (!newInfo.is_null()) {
Json::array modifiedMatches;
for (auto & match : newInfo["games"].array_items()) {
auto item = match.object_items();
item["summonerId"] = kv.first;
item["name"] = kv.second["name"].string_value();
modifiedMatches.push_back(item);
}
matches.insert(matches.end(), modifiedMatches.begin(), modifiedMatches.end());
sort(matches.begin(), matches.end(), cmp);
Json::object updateObject(kv.second.object_items());
updateObject["games"] = modifiedMatches;
_service->saveSummonerInfo(kv.first, Json(updateObject));
}
_onRead(matches);
});
}
return Json(matches);
}
int main(int argc, char *argv[])
{
try
{
Json js;
std::string str("Test\\ string\\ end\\\nAnders was here\n\"Quoted string inside string\"\n");
std::cout << " --------------- original\n";
std::cout << str << std::endl;
js.encode(str);
std::cout << " --------------- encoded\n";
std::cout << str << std::endl;
js.decode(str);
std::cout << " --------------- decoded\n";
std::cout << str << std::endl;
js["String"] = str;
str = js.ToString();
std::cout << " --------------- from ToString()\n";
std::cout << str << std::endl;
Json js2 = Json::Parse(str);
std::cout << js2.ToString() << std::endl;
std::cout << (std::string)js2["String"] << std::endl;
str = "{\"no-value\":null}";
Json js3 = Json::Parse(str);
std::cout << js3.ToString() << std::endl;
std::cout << " --------------- request\n";
Json req;
req["method"] = "test";
Json params;
params["value1"] = 1L;
params["value2"] = "2";
req["params"] = params;
std::cout << req.ToString() << std::endl;
}
catch (const Exception& e)
{
std::cerr << e.ToString() << std::endl;
}
}
void
SqliteStore::set(const string& key, const Json& value) {
auto serialized = value.dump();
sqlite::WriteTransaction guard {m_stmts};
bool did_update = false;
{
auto& stmt = m_update;
stmt->reset();
stmt->bind(1, key);
stmt->bind(2, serialized);
did_update = stmt->exec() > 0;
}
if (!did_update) {
auto& stmt = m_insert;
stmt->reset();
stmt->bind(1, key);
stmt->bind(2, serialized);
stmt->exec();
}
guard.commit();
}
int main(int argc, char* argv[])
{
std::string compiler;
std::string compilerPath;
Vstring linklineA;
extract_linker(compiler, compilerPath, linklineA);
Json json;
json.add("compiler", compiler);
json.add("compilerPath", compilerPath);
json.add("link_line", linklineA);
json.fini();
std::string jsonStr = json.result();
fprintf(stdout,"%s\n",jsonStr.c_str());
return 0;
}
EResult<Json> Monica::findAndReplaceReferences(const Json& root, const Json& j)
{
auto sp = supportedPatterns();
//auto jstr = j.dump();
bool success = true;
vector<string> errors;
if(j.is_array() && j.array_items().size() > 0)
{
J11Array arr;
bool arrayIsReferenceFunction = false;
if(j[0].is_string())
{
auto p = sp.find(j[0].string_value());
if(p != sp.end())
{
arrayIsReferenceFunction = true;
//check for nested function invocations in the arguments
J11Array funcArr;
for(auto i : j.array_items())
{
auto r = findAndReplaceReferences(root, i);
success = success && r.success();
if(!r.success())
for(auto e : r.errors)
errors.push_back(e);
funcArr.push_back(r.result);
}
//invoke function
auto jaes = (p->second)(root, funcArr);
success = success && jaes.success();
if(!jaes.success())
for(auto e : jaes.errors)
errors.push_back(e);
//if successful try to recurse into result for functions in result
if(jaes.success())
{
auto r = findAndReplaceReferences(root, jaes.result);
success = success && r.success();
if(!r.success())
for(auto e : r.errors)
errors.push_back(e);
return{r.result, errors};
}
else
return{J11Object(), errors};
}
}
if(!arrayIsReferenceFunction)
for(auto jv : j.array_items())
{
auto r = findAndReplaceReferences(root, jv);
success = success && r.success();
if(!r.success())
for(auto e : r.errors)
errors.push_back(e);
arr.push_back(r.result);
}
return{arr, errors};
}
else if(j.is_object())
{
J11Object obj;
for(auto p : j.object_items())
{
auto r = findAndReplaceReferences(root, p.second);
success = success && r.success();
if(!r.success())
for(auto e : r.errors)
errors.push_back(e);
obj[p.first] = r.result;
}
return{obj, errors};
}
return{j, errors};
}
CollectOptions::CollectOptions (Json const& json) {
Json obj = json.get("collectOptions");
method = methodFromString(JsonHelper::getStringValue(obj.json(), "method", ""));
}
void BlockColors::load(const std::string& zipFileName, const std::string& cacheFileName)
{
using namespace json11;
//Keep filenames for later
this->zipFileName = zipFileName;
this->cacheFileName = cacheFileName;
//Zip file interface
auto archive = ZipFile::Open(zipFileName);
//Cache JSON. This is a single { } of key:value of "blockid-meta" to .zip CRC and RGBA color
// ex: {"2-4": {"crc": 5234231, "color": 2489974272}, ... }
std::string parseErr;
Json cacheJson = Json::parse(readFile(cacheFileName), parseErr);
if(!parseErr.empty()) {
log("Could not read cache \"", cacheFileName, "\": ", parseErr);
}
/* Will be true if computeColor is called, basically if cache is missing
* or CRC changed in zip for any file */
bool hadToRecompute = false;
for(unsigned i = 0; i != archive->GetEntriesCount(); ++i)
{
/* Name and CRC of the block image in .zip
* substr on the name is used to cut off the .png at the end */
auto entry = archive->GetEntry(i);
unsigned zipcrc = entry->GetCrc32();
std::string name = entry->GetName();
name = name.substr(0, name.find('.'));
/* To get a block color, first the cache is checked.
* if it's not there, the color is recomputed. If that happens,
* "hadToRecompute" is set to true, and a new .json cache will be written out */
Json key = cacheJson[name];
if(key.is_null()) {
//Look for key with a 0 meta. e.g, "404-0" and not "404"
std::string nameWithMeta = name + "-0";
key = cacheJson[nameWithMeta];
}
SDL_Color blockColor;
if(key.is_object() && (unsigned)key["crc"].int_value() == zipcrc) {
Uint32 cachePixel = key["color"].int_value();
SDL_GetRGBA(cachePixel, rgba, &blockColor.r, &blockColor.g, &blockColor.b, &blockColor.a);
} else {
blockColor = computeColor(entry);
hadToRecompute = true;
}
//Store color and CRC in this object
blockColors[name] = std::make_pair(blockColor, zipcrc);
}
//If any blocks were not found in cache
if(hadToRecompute) {
saveNewJsonCache();
}
}
Entity SceneLoader::instantiate(Json def, Resources& resources, const string& pathContext)
{
ASSERT(def.is_object());
if (def["prefab"].is_string()) {
const string& prefabName = def["prefab"].string_value();
auto prefabIter = prefabs.find(prefabName);
if (prefabIter != prefabs.end()) {
def = assign(prefabIter->second, def);
} else if (endsWith(prefabName, ".json")) {
string err;
Json extPrefab = Json::parse(resources.getText(resolvePath(pathContext, prefabName), Resources::NO_CACHE), err);
if (!err.empty()) {
logError("Failed to parse prefab \"%s\": %s", prefabName.c_str(), err.c_str());
} else {
def = assign(extPrefab, def);
prefabs[prefabName] = extPrefab;
}
} else {
logError("Could not find prefab \"%s\"", prefabName.c_str());
}
}
Entity entity = world->create();
if (def["name"].is_string()) {
entity.tag(def["name"].string_value());
#ifdef USE_DEBUG_NAMES
DebugInfo info;
info.name = def["name"].string_value();
entity.add<DebugInfo>(info);
} else {
static uint debugId = 0;
DebugInfo info;
if (def["prefab"].is_string())
info.name = def["prefab"].string_value() + "#";
else if (def["geometry"].is_string())
info.name = def["geometry"].string_value() + "#";
else info.name = "object#";
info.name += std::to_string(debugId++);
entity.tag(info.name);
entity.add<DebugInfo>(info);
#endif
}
// Parse transform
if (!def["position"].is_null() || !def["rotation"].is_null() || !def["scale"].is_null() || !def["geometry"].is_null()) {
Transform transform;
setVec3(transform.position, def["position"]);
setVec3(transform.scale, def["scale"]);
if (!def["rotation"].is_null()) {
const Json& rot = def["rotation"];
if (rot.is_array() && rot.array_items().size() == 4)
transform.rotation = quat(rot[3].number_value(), rot[0].number_value(), rot[1].number_value(), rot[2].number_value());
else transform.rotation = quat(toVec3(rot));
}
entity.add(transform);
}
// Parse light
const Json& lightDef = def["light"];
if (!lightDef.is_null()) {
Light light;
const string& lightType = lightDef["type"].string_value();
if (lightType == "ambient") light.type = Light::AMBIENT_LIGHT;
else if (lightType == "point") light.type = Light::POINT_LIGHT;
else if (lightType == "directional") light.type = Light::DIRECTIONAL_LIGHT;
else if (lightType == "spot") light.type = Light::SPOT_LIGHT;
else if (lightType == "area") light.type = Light::AREA_LIGHT;
else if (lightType == "hemisphere") light.type = Light::HEMISPHERE_LIGHT;
else logError("Unknown light type \"%s\"", lightType.c_str());
setColor(light.color, lightDef["color"]);
if (!def["position"].is_null())
light.position = toVec3(def["position"]);
if (!lightDef["direction"].is_null())
light.direction = toVec3(lightDef["direction"]);
setNumber(light.distance, lightDef["distance"]);
setNumber(light.decay, lightDef["decay"]);
entity.add(light);
numLights++;
}
if (!def["geometry"].is_null()) {
Model model;
parseModel(model, def, resources, pathContext);
entity.add(model);
numModels++;
}
// Patch bounding box
// TODO: Bounding box is not correct if scale changed at runtime
if (entity.has<Model>() && entity.has<Transform>()) {
Model& model = entity.get<Model>();
const Transform& trans = entity.get<Transform>();
model.bounds.min = model.lods[0].geometry->bounds.min * trans.scale;
model.bounds.max = model.lods[0].geometry->bounds.max * trans.scale;
model.bounds.radius = model.lods[0].geometry->bounds.radius * glm::compMax(trans.scale);
}
// Parse body (needs to be after geometry, transform, bounds...)
if (!def["body"].is_null()) {
const Json& bodyDef = def["body"];
ASSERT(bodyDef.is_object());
ASSERT(entity.has<Model>());
ASSERT(entity.has<Transform>());
const Model& model = entity.get<Model>();
const Transform& transform = entity.get<Transform>();
float mass = 0.f;
setNumber(mass, bodyDef["mass"]);
btCollisionShape* shape = NULL;
const string& shapeStr = bodyDef["shape"].string_value();
vec3 extents = model.bounds.max - model.bounds.min;
if (shapeStr == "box") {
shape = new btBoxShape(convert(extents * 0.5f));
} else if (shapeStr == "sphere") {
shape = new btSphereShape(model.bounds.radius);
} else if (shapeStr == "cylinder") {
shape = new btCylinderShape(convert(extents * 0.5f));
} else if (shapeStr == "capsule") {
float r = glm::max(extents.x, extents.z) * 0.5f;
shape = new btCapsuleShape(r, extents.y);
} else if (shapeStr == "trimesh") {
Geometry* colGeo = nullptr;
if (bodyDef["geometry"].is_string()) {
colGeo = resources.getGeometry(bodyDef["geometry"].string_value());
} else {
if (bodyDef["geometry"].is_array())
logError("LODs not supported for collision mesh.");
colGeo = model.lods[0].geometry;
}
if (!colGeo->collisionMesh)
colGeo->generateCollisionTriMesh();
if (mass <= 0.f) { // Static mesh
shape = new btBvhTriangleMeshShape(colGeo->collisionMesh, true);
} else {
shape = new btGImpactMeshShape(colGeo->collisionMesh);
static_cast<btGImpactMeshShape*>(shape)->updateBound();
}
} else {
logError("Unknown shape %s", shapeStr.c_str());
}
ASSERT((shapeStr == "trimesh" || bodyDef["geometry"].is_null()) && "Trimesh shape type required if body.geometry is specified");
ASSERT(shape);
btVector3 inertia(0, 0, 0);
shape->calculateLocalInertia(mass, inertia);
btRigidBody::btRigidBodyConstructionInfo info(mass, NULL, shape, inertia);
info.m_startWorldTransform = btTransform(convert(transform.rotation), convert(transform.position));
setNumber(info.m_friction, bodyDef["friction"]);
setNumber(info.m_rollingFriction, bodyDef["rollingFriction"]);
setNumber(info.m_restitution, bodyDef["restitution"]);
if (bodyDef["noSleep"].bool_value()) {
info.m_linearSleepingThreshold = 0.f;
info.m_angularSleepingThreshold = 0.f;
}
entity.add<btRigidBody>(info);
numBodies++;
btRigidBody& body = entity.get<btRigidBody>();
if (!bodyDef["angularFactor"].is_null())
body.setAngularFactor(convert(toVec3(bodyDef["angularFactor"])));
if (!bodyDef["linearFactor"].is_null())
body.setLinearFactor(convert(toVec3(bodyDef["linearFactor"])));
if (bodyDef["noGravity"].bool_value())
body.setFlags(body.getFlags() | BT_DISABLE_WORLD_GRAVITY);
body.setUserIndex(entity.get_id());
if (world->has_system<PhysicsSystem>())
world->get_system<PhysicsSystem>().add(entity);
}
if (!def["animation"].is_null()) {
ASSERT(entity.has<Model>());
const Json& animDef = def["animation"];
BoneAnimation anim;
setNumber(anim.speed, animDef["speed"]);
entity.add(anim);
if (animDef["play"].is_bool() && animDef["play"].bool_value())
world->get_system<AnimationSystem>().play(entity);
else world->get_system<AnimationSystem>().stop(entity);
}
if (def["trackGround"].bool_value()) {
ASSERT(entity.has<btRigidBody>());
entity.add<GroundTracker>();
}
if (def["trackContacts"].bool_value()) {
ASSERT(entity.has<btRigidBody>());
entity.add<ContactTracker>();
}
if (def["triggerVolume"].is_object()) {
ASSERT(entity.has<Transform>());
const Json& triggerDef = def["triggerVolume"];
TriggerVolume& trigger = entity.add<TriggerVolume>();
setNumber(trigger.times, triggerDef["times"]);
setNumber(trigger.bounds.radius, triggerDef["radius"]);
setVec3(trigger.bounds.min, triggerDef["min"]);
setVec3(trigger.bounds.min, triggerDef["max"]);
if (triggerDef["receiver"].is_string())
trigger.receiverModule = id::hash(triggerDef["receiver"].string_value());
if (triggerDef["enterMessage"].is_string())
trigger.enterMessage = id::hash(triggerDef["enterMessage"].string_value());
else if (triggerDef["enterMessage"].is_number())
trigger.enterMessage = triggerDef["enterMessage"].number_value();
if (triggerDef["exitMessage"].is_string())
trigger.exitMessage = id::hash(triggerDef["exitMessage"].string_value());
else if (triggerDef["exitMessage"].is_number())
trigger.exitMessage = triggerDef["exitMessage"].number_value();
if (triggerDef["groups"].is_number())
trigger.groups = 1 << (uint)triggerDef["groups"].number_value();
else if (triggerDef["groups"].is_array()) {
for (const auto& item : triggerDef["groups"].array_items())
trigger.groups |= 1 << (uint)item.number_value();
}
}
if (def["triggerGroup"].is_number()) {
ASSERT(entity.has<Transform>());
entity.add<TriggerGroup>().group = 1 << (uint)def["triggerGroup"].number_value();
}
if (!def["moveSound"].is_null()) {
const Json& soundDef = def["moveSound"];
MoveSound sound;
if (soundDef["event"].is_string())
sound.event = id::hash(soundDef["event"].string_value());
setNumber(sound.stepLength, soundDef["step"]);
ASSERT(sound.event);
ASSERT(entity.has<Transform>());
sound.prevPos = entity.get<Transform>().position;
entity.add(sound);
}
if (!def["contactSound"].is_null()) {
const Json& soundDef = def["contactSound"];
ContactSound sound;
if (soundDef["event"].is_string())
sound.event = id::hash(soundDef["event"].string_value());
ASSERT(sound.event);
ASSERT(entity.has<Transform>());
ASSERT(entity.has<ContactTracker>());
entity.add(sound);
}
return entity;
}
int main(int argc, char **argv) {
if (argc == 2 && argv[1] == string("--stdin")) {
parse_from_stdin();
return 0;
}
const string simple_test =
R"({"k1":"v1", "k2":42, "k3":["a",123,true,false,null]})";
string err;
auto json = Json::parse(simple_test, err);
std::cout << "k1: " << json["k1"].string_value() << "\n";
std::cout << "k3: " << json["k3"].dump() << "\n";
for (auto &k : json["k3"].array_items()) {
std::cout << " - " << k.dump() << "\n";
}
std::list<int> l1 { 1, 2, 3 };
std::vector<int> l2 { 1, 2, 3 };
std::set<int> l3 { 1, 2, 3 };
assert(Json(l1) == Json(l2));
assert(Json(l2) == Json(l3));
std::map<string, string> m1 { { "k1", "v1" }, { "k2", "v2" } };
std::unordered_map<string, string> m2 { { "k1", "v1" }, { "k2", "v2" } };
assert(Json(m1) == Json(m2));
// Json literals
Json obj = Json::object({
{ "k1", "v1" },
{ "k2", 42.0 },
{ "k3", Json::array({ "a", 123.0, true, false, nullptr }) },
});
std::cout << "obj: " << obj.dump() << "\n";
assert(Json("a").number_value() == 0);
assert(Json("a").string_value() == "a");
assert(Json().number_value() == 0);
assert(obj == json);
assert(Json(42) == Json(42.0));
assert(Json(42) != Json(42.1));
const string unicode_escape_test =
R"([ "blah\ud83d\udca9blah\ud83dblah\udca9blah\u0000blah\u1234" ])";
const char utf8[] = "blah" "\xf0\x9f\x92\xa9" "blah" "\xed\xa0\xbd" "blah"
"\xed\xb2\xa9" "blah" "\0" "blah" "\xe1\x88\xb4";
Json uni = Json::parse(unicode_escape_test, err);
assert(uni[0].string_value().size() == (sizeof utf8) - 1);
assert(memcmp(uni[0].string_value().data(), utf8, sizeof utf8) == 0);
Json my_json = Json::object {
{ "key1", "value1" },
{ "key2", false },
{ "key3", Json::array { 1, 2, 3 } },
};
std::string json_str = my_json.dump();
printf("%s\n", json_str.c_str());
class Point {
public:
int x;
int y;
Point (int x, int y) : x(x), y(y) {}
Json to_json() const { return Json::array { x, y }; }
};
std::vector<Point> points = { { 1, 2 }, { 10, 20 }, { 100, 200 } };
std::string points_json = Json(points).dump();
printf("%s\n", points_json.c_str());
}
EarthViewer(const Vec2<int>& size, const float scale, const bool oblong, Touch& touch, Keyinp& keyinp, const std::string& path, const std::string& lang) :
touch_(touch),
keyinp_(keyinp),
size_(size.x / scale, size.y / scale),
params_(path + "devdata/params.json"),
scale_(scale),
aspect_((float)size.x / (float)size.y),
camera_(Camera::PERSPECTIVE),
cockpit_(Camera::ORTHOGONAL),
localize_(lang, path),
earth_(params_.value().get<picojson::object>()["earth"].get<picojson::object>(), path, camera_),
rotate_mix_(),
place_index_()
{
DOUT << "EarthViewer()" << std::endl;
picojson::object& params = params_.value().get<picojson::object>();
camera_.oblong(oblong);
SetupCamera(camera_, params["camera"].get<picojson::object>(), aspect_);
cockpit_.setSize(size.x / scale, size.y / scale);
{
picojson::array& array = params["lights"].get<picojson::array>();
for (picojson::array::iterator it = array.begin(); it != array.end(); ++it)
{
Light light;
SetupLight(light, it->get<picojson::object>());
lights_.push_back(light);
}
earth_.light(lights_);
}
env_.touch = &touch_;
env_.keyinp = &keyinp_;
env_.path = &path;
env_.savePath = &path;
env_.size = &size_;
env_.scale = scale_;
env_.params = ¶ms_;
env_.task = &task_;
env_.camera = &camera_;
env_.cockpit = &cockpit_;
env_.earth = &earth_;
env_.earthLight = &lights_[0];
env_.fonts = &fonts_;
env_.texMng = &texMng_;
env_.localize = &localize_;
env_.earth_texture = 0;
earth_.texture(env_.earth_texture);
earth_.setRotSpeed(0);
{
const std::string& file = params["game"].get<picojson::object>()["places"].get<std::string>();
Json places = Json(path + file);
places_ = places.value().get<picojson::object>();
for (picojson::object::iterator it = places_.begin(); it != places_.end(); ++it)
{
place_names_.push_back(&it->first);
}
}
task_.add<Control>(TASK_PRIO_SYS, env_);
task_.add<Game2DSetup>(TASK_PRIO_2D_TOPPRIO, env_);
task_.add<GameWorld>(TASK_PRIO_3D_TOPPRIO, env_);
env_.task->add<PlaceDisp>(TASK_PRIO_2D, env_);
// task_.add<Equator>(TASK_PRIO_3D, env_);
task_.add<TouchEft>(TASK_PRIO_3D, env_);
}
// get anonimous user
Json
get_anon(){
Json ret = Json::object();
ret.set("level", LEVEL_ANON);
return ret;
}
void
do_write(const CFG & cfg, int argc, char **argv){
Err("write"); // set error domain
check_args(argc, 1); // check argument number
char * dbname = argv[1]; // database name
/* check length and symbols in the database name */
check_name(dbname);
/* Get user information. Empty session is an error */
UserDB udb(cfg, DB_RDONLY);
Json user = udb.get_by_session(get_secret());
clr_secret();
if (!user) throw Err() << "authentication error";
/* read JSON object from stdin */
Json data = Json::load_stream(stdin);
/* get id from object or set it to -1 */
json_int_t id =-1;
if (data.exists("id")) id = data["id"].as_integer();
else data.set("id", id);
/* del field should be 1 if exists */
if (data.exists("del")){
if (data["del"].as_integer()!=0) data.set("del", 1);
else data.del("del");
}
/* Open database; LEVEL_ADMIN can create a new one */
json_int_t level = user["level"].as_integer();
size_t dbflags = (level>= LEVEL_ADMIN)? DB_CREATE:0;
DataDB db(cfg, dbname, dbflags); // open database
/* Set mtime and muser fields */
data.set("mtime", (json_int_t)time(NULL));
data.set("muser", user["sid"]);
/* Set ctime, cuser, prev fields, store old version in archive if needed */
if (id==-1){ // new object
data.set("ctime", (json_int_t)time(NULL));
data.set("cuser", user["sid"]);
data.set("prev", -1);
}
else { // replace object
/* check is the old version exists*/
if (!db.exists(id)) throw Err() << "bad id";
Json old = db.get(id); // old object
/* check permissions */
if (old["cuser"].as_string() != user["sid"].as_string() && level < LEVEL_MODER)
throw Err() << "not enough permissions to edit";
data.set("ctime", old["ctime"]);
data.set("cuser", old["cuser"]);
old.set("id", -1);
db.arc.put(old);
data.set("prev", old["id"]);
}
/* build date_key */
if (data.exists("date1") && data["date1"].is_string() &&
data.exists("date2") && data["date2"].is_string()){
//put in data_key first common part of date1 and date2
string d1 = data["date1"].as_string();
string d2 = data["date2"].as_string();
string dk = "";
for (int i=0;i<std::min(d1.length(),d2.length());i++){
if (d1[i]==d2[i]) dk+=d1[i];
else break;
}
data.set("date_key", dk);
}
else {
// remove date_key field if it exists
if (data.exists("date_key")) data.del("date_key");
}
/* build coord_key */
if (data.exists("lat1") && data["lat1"].is_number() &&
data.exists("lat2") && data["lat2"].is_number() &&
data.exists("lon1") && data["lon1"].is_number() &&
data.exists("lon2") && data["lon2"].is_number()){
double lat1 = data["lat1"].as_real();
double lat2 = data["lat2"].as_real();
double lon1 = data["lon1"].as_real();
double lon2 = data["lon2"].as_real();
string ck="";
// todo
data.set("coord_key", ck);
}
else {
// remove coord_key field if it exists
if (data.exists("coord_key")) data.del("coord_key");
}
db.put(data); // put data
throw Exc() << data.save_string(JSON_OUT_FLAGS);
}
Ranking(GameEnv& env, const int mode, const bool record) :
env_(env),
active_(true),
mode_(mode),
record_(record),
params_(env.params->value().get<picojson::object>()["ranking"].get<picojson::object>()),
rank_tbl_(env.params->value().get<picojson::object>()["rank_tbl"].get<picojson::array>()),
json_(isSavedParamExists(*env.savePath + "results.json") ? *env.savePath + "results.json" : *env.path + "devdata/results.json"),
font_(ReadFont("ranking", *env.fonts, *env.path, env.params->value().get<picojson::object>())),
texture_(env.texMng->read(*env.path + "devdata/round.png")),
title_(params_["title"].get<picojson::array>()[mode_].get<std::string>()),
skip_delay_(params_["skip_delay"].get<double>()),
do_skip_(),
wipe_(true),
time_cur_(),
time_ed_(params_["time_ed"].get<double>()),
ofs_st_(1, 0, 1),
ofs_ed_(0, 1, 0),
scale_(),
scale_st_(0),
scale_ed_(1),
scale_time_ed_(time_ed_ * 0.4),
disp_time_(record ? 0 : params_["disp_time"].get<double>()),
col_(1, 1, 1, 1),
col_index_(),
col_timer_(),
col_demo_time_(10000), // 最初は動かさない
col_demo_time_ed_(params_["col_demo_time"].get<double>()),
col_demo_index_(RESULT_NUM),
agree_(),
touched_(),
finish_()
{
DOUT << "Ranking()" << std::endl;
static const char *record_tbl[] = {
"normal",
"advanced",
"survival"
};
picojson::array& array = json_.value().get<picojson::object>()[record_tbl[mode_]].get<picojson::array>();
// FIXME:コードの下の方でも array を使ってます
for (picojson::array::iterator it = array.begin(); it != array.end(); ++it)
{
int level = it->get<picojson::object>()["level"].get<double>();
int konahen = it->get<picojson::object>()["konahen"].get<double>();
int score = it->get<picojson::object>()["score"].get<double>();
int rank = it->get<picojson::object>()["rank"].get<double>();
GameResult result = {
level,
konahen,
score,
rank,
false
};
results_.push_back(result);
}
if (record_)
{
GameResult result = {
env_.level + 1,
env_.konahen,
env_.score,
env_.rank,
true
};
results_.push_back(result);
{
picojson::object obj;
obj["level"] = picojson::value((float)result.level);
obj["konahen"] = picojson::value((float)result.konahen);
obj["score"] = picojson::value((float)result.score);
obj["rank"] = picojson::value((float)result.rank);
array.push_back(picojson::value(obj));
std::string fpath = *env_.savePath + "results.json";
json_.write(fpath);
}
}
std::sort(results_.begin(), results_.end());
std::reverse(results_.begin(), results_.end());
results_.resize(RESULT_NUM);
bool played = false;
int index = 0;
for (std::vector<GameResult>::iterator it = results_.begin(); it != results_.end(); ++it, ++index)
{
if (it->played)
{
played = it->played;
break;
}
}
// FIXME:ここはアルゴリズムを使うべきか…
if (played && (index < RANKIN_INDEX))
{
switch (env_.game_mode)
{
case GAME_MODE_NORMAL:
{
AchievementUnlock("advanced", env_);
}
break;
case GAME_MODE_ADVANCED:
{
AchievementUnlock("survival", env_);
}
break;
case GAME_MODE_SURVIVAL:
{
AchievementUnlock("earth_texture", env_);
}
break;
}
// ランクインしたら実績解除
}
env_.sound->play("ranking", 1, 0.6);
env_.touch->resistCallBack(this);
}
ShortestPathOptions::ShortestPathOptions(Json const& json) {
Json obj = json.get("shortestpathFlags");
weightAttribute = JsonHelper::getStringValue(obj.json(), "weightAttribute", "");
defaultWeight = JsonHelper::getNumericValue<double>(obj.json(), "defaultWeight", 1);
}
int main (int argc, char *argv[]) {
google::InitGoogleLogging(argv[0]);
namespace po = boost::program_options;
string root;
string synsets_path;
string out_path;
size_t streams;
double file_gbs;
double container_mbs;
unsigned threads;
int resize;
int max;
int label;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message.")
("synsets", po::value(&synsets_path)->default_value("synsets.txt"), "")
("root", po::value(&root), "")
("out", po::value(&out_path), "")
("streams,s", po::value(&streams)->default_value(20), "")
("file-gbs,f", po::value(&file_gbs)->default_value(4), "")
("container-mbs,c", po::value(&container_mbs)->default_value(200), "")
("threads,t", po::value(&threads)->default_value(0), "")
("resize,r", po::value(&resize)->default_value(256), "")
("max", po::value(&max)->default_value(0), "")
("label", po::value(&label)->default_value(-1), "")
;
po::positional_options_description p;
p.add("root", 1);
p.add("out", 1);
p.add("synsets", 1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).
options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help") || !root.size() || !out_path.size()) {
cerr << desc;
return 1;
}
vector<string> tar_paths;
{
ifstream is(synsets_path);
string synset;
while (is >> synset) {
string path = root + "/" + synset + ".tar";
LOG_IF(ERROR, !boost::filesystem::exists(path)) << "cannot find path " << path;
tar_paths.push_back(path);
}
LOG(INFO) << "Loaded " << tar_paths.size() << " tar paths." << endl;
}
Geometry geometry;
geometry.n_stream = streams;
geometry.file_size = round(file_gbs * GB);
geometry.container_size = round(container_mbs * MB);
{
boost::timer::auto_cpu_timer t;
DataSet dataset(out_path, geometry, 0);
std::atomic<unsigned> serial(0);
std::atomic<unsigned> done(0);
#pragma omp parallel for
for (unsigned i = 0; i < tar_paths.size(); ++i) {
Record rec;
rec.meta.label = label >= 0 ? label : i;
Tar tar(tar_paths[i]);
vector<uint8_t> jpeg;
Tar::posix_header const *header;
while (tar.next(&jpeg, &header)) {
rec.meta.serial = serial.fetch_add(1);
if (max && rec.meta.serial >= max) break;
cv::Mat image = cv::imdecode(cv::Mat(jpeg), cv::IMREAD_COLOR);
if (image.total() == 0) {
LOG(WARNING) << "fail to load image of size " << jpeg.size();
continue;
}
if (resize) {
cv::Mat image2;
cv::resize(image, image2, cv::Size(resize, resize));
cv::imencode(".jpg", image2, jpeg);
}
Json json = Json::object {
{"fname", header->name},
{"ocols", image.cols},
{"orows", image.rows}
};
string extra = json.dump();
rec.image_size = jpeg.size();
rec.image = reinterpret_cast<char const *>(&jpeg[0]);
rec.extra = &extra[0];
rec.extra_size = extra.size();
unsigned n = rec.meta.serial + 1;
LOG_IF(INFO, n && ((n % 1000) == 0)) << done << '/' << tar_paths.size() << " tar_paths, " << serial << " images.";
#pragma omp critical
dataset << rec;
}
++done;
}
}
}
bool Pb2Json::Json2RepeatedMessage(const Json& json, ProtobufMsg& message, const ProtobufFieldDescriptor* field,
const ProtobufReflection* reflection, bool str2enum) {
int count = json.count(field->name());
for (auto j = 0; j < count; ++j) {
switch (field->type()) {
case ProtobufFieldDescriptor::TYPE_BOOL: {
if (json[j].is_boolean())
reflection->AddBool(&message, field, json[j].get<bool>());
else if (json[j].is_number_integer())
reflection->AddBool(&message, field, json[j].get<uint32_t>() != 0);
else if (json[j].is_string()) {
if (json[j].get<std::string>() == "true")
reflection->AddBool(&message, field, true);
else if (json[j].get<std::string>() == "false")
reflection->AddBool(&message, field, false);
}
} break;
case ProtobufFieldDescriptor::TYPE_ENUM: {
auto const* pedesc = field->enum_type();
const ::google::protobuf::EnumValueDescriptor* pevdesc = nullptr;
if (str2enum) {
pevdesc = pedesc->FindValueByName(json[j].get<std::string>());
} else {
pevdesc = pedesc->FindValueByNumber(json[j].get<int32_t>());
}
if (nullptr != pevdesc) {
reflection->AddEnum(&message, field, pevdesc);
}
} break;
case ProtobufFieldDescriptor::TYPE_INT32:
case ProtobufFieldDescriptor::TYPE_SINT32:
case ProtobufFieldDescriptor::TYPE_SFIXED32: {
if (json[j].is_number()) reflection->AddInt32(&message, field, json[j].get<int32_t>());
} break;
case ProtobufFieldDescriptor::TYPE_UINT32:
case ProtobufFieldDescriptor::TYPE_FIXED32: {
if (json[j].is_number()) reflection->AddUInt32(&message, field, json[j].get<uint32_t>());
} break;
case ProtobufFieldDescriptor::TYPE_INT64:
case ProtobufFieldDescriptor::TYPE_SINT64:
case ProtobufFieldDescriptor::TYPE_SFIXED64: {
if (json[j].is_number()) reflection->AddInt64(&message, field, json[j].get<int64_t>());
} break;
case ProtobufFieldDescriptor::TYPE_UINT64:
case ProtobufFieldDescriptor::TYPE_FIXED64: {
if (json[j].is_number()) reflection->AddUInt64(&message, field, json[j].get<uint64_t>());
} break;
case ProtobufFieldDescriptor::TYPE_FLOAT: {
if (json[j].is_number()) reflection->AddFloat(&message, field, json[j].get<float>());
} break;
case ProtobufFieldDescriptor::TYPE_DOUBLE: {
if (json[j].is_number()) reflection->AddDouble(&message, field, json[j].get<double>());
} break;
case ProtobufFieldDescriptor::TYPE_MESSAGE: {
if (json[j].is_object()) Json2Message(json[j], *reflection->AddMessage(&message, field));
} break;
case ProtobufFieldDescriptor::TYPE_STRING:
case ProtobufFieldDescriptor::TYPE_BYTES: {
if (json[j].is_string()) reflection->AddString(&message, field, json[j].get<std::string>());
} break;
default:
break;
}
}
return true;
}
void IPCManager::HandleMessage(int show_id, const std::string& data) {
// TODO: adjust to protobuf
ParseData(data);
while (true) {
std::string next_message = "";
if (GetNextMessage(next_message)) {
std::string err;
auto json = Json::parse(next_message, err);
if (!err.empty()) {
std::cout << "error: " << err << std::endl;
continue;
}
// std::cout << "message: " << next_message << std::endl;
std::string action = json["action"].string_value();
// std::cout << "action: " << action << std::endl;
if (action == "request") {
// 请求
int req_id = json["id"].int_value();
std::string method = json["method"].string_value();
std::string req = json["request"].string_value();
if (ipc_info_map_[show_id].method_map.find(method) !=
ipc_info_map_[show_id].method_map.end()) {
std::string response = "";
(ipc_info_map_[show_id].method_map[method])(req, response);
Json obj = Json::object({
{ "action", "response" },
{ "id", req_id },
{ "method", method },
{ "response", response },
{ "code", ErrorOK },
});
ipc_info_map_[show_id].fifo->Write(obj.dump());
} else {
Json obj = Json::object({
{ "action", "response" },
{ "id", req_id },
{ "method", method },
{ "error", "no such api." },
{ "code", ErrorNoSuchAPI },
});
ipc_info_map_[show_id].fifo->Write(obj.dump());
}
} else if (action == "init") {
// 收到客户端发过来的初始化完成的消息
if (ipc_info_map_[show_id].fifo->OpenClientFile()) {
if (ipc_info_map_[show_id].server_delegate != nullptr) {
ipc_info_map_[show_id].server_delegate->OnAcceptNewClient(this, show_id);
}
} else {
std::cout << "open client failed: " << errno;
}
} else if (action == "response") {
// 请求的回应
std::string method = json["method"].string_value();
if (ipc_info_map_[show_id].method_callback_map.find(method) != ipc_info_map_[show_id].method_callback_map.end()) {
int req_id = json["id"].int_value();
if (ipc_info_map_[show_id].method_callback_map[method].find(req_id)
!= ipc_info_map_[show_id].method_callback_map[method].end()) {
ErrorCode code = ErrorCode((json["code"].int_value()));
if (code == ErrorOK) {
std::string req = json["response"].string_value();
(ipc_info_map_[show_id].method_callback_map[method][req_id])(code, req);
} else {
std::string error = json["error"].string_value();
(ipc_info_map_[show_id].method_callback_map[method][req_id])(code, error);
}
}
}
} else if (action == "close") {
// 关闭
if (ipc_info_map_[show_id].client_delegate != nullptr) {
ipc_info_map_[show_id].client_delegate->OnServerClose(this);
}
}
} else {
break;
}
}
}
static void processFile(const boost::filesystem::path &path, int hrsOffset, result_t &results)
{
std::string fn = path.string();
std::time_t t = boost::filesystem::last_write_time(path);
boost::posix_time::ptime lwt = boost::posix_time::from_time_t(t);
lwt = boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local(lwt);
lwt += boost::posix_time::time_duration(hrsOffset, 0, 0, 0);
StatusReport statusReport(fn);
std::ifstream in(fn.c_str());
Json json;
while (!in.eof())
{
char c;
in.get(c);
json.nextChar(c);
}
map_t::const_iterator itor = json.getMap().find("eventlog");
if (itor != json.getMap().end())
{
std::vector<std::string> v;
json.getArray(itor->second, v);
if (v.size() > 1)
{ // more than just labels
std::vector<std::string> labels;
json.getArray(v[0], labels);
std::map<int, int> colMap;
for (int j = 0; j < (int)NUM_COLUMNS; j++)
{
std::string l; l += '"'; l += Columns[j]; l += '"';
for (int k = 0; k < labels.size(); k++)
{
if (labels[k] == l)
colMap[j] = k;
}
}
if (colMap.size() == (int)NUM_COLUMNS)
{ // every column we expect appears?
for (int i = 1; i < v.size(); i++)
{
std::vector<std::string> vals;
json.getArray(v[i], vals);
if (vals.size() == labels.size())
{ // this record has an entry for every label?
boost::posix_time::time_duration todFile = lwt.time_of_day();
int todHors = todFile.hours();
int todMins = todFile.minutes();
int hrs = atoi(vals[colMap[HOUR]].c_str());
int min = atoi(vals[colMap[MINUTE]].c_str());
boost::posix_time::time_duration tod(hrs, min, 0, 0), delta;
delta = tod - todFile;
const int minMin = 2;
if (delta.total_seconds() > (minMin * 60)) // assume rolled over midnight
delta -= boost::posix_time::time_duration(24,0,0,0);
long ts = delta.total_seconds();
const int maxMin = 120;
if ((ts > (minMin * 60)) || (ts < (maxMin * -60)))
{
std::ostringstream oss;
oss << "Time label (" << hrs << ':' << min << ") not in window " << maxMin << "min before file stamp ("
<< todHors << ':' << todMins << ") ts=" << ts;
statusReport.report(oss.str());
continue;
}
boost::posix_time::ptime tstamp = lwt + delta;
results[tstamp] = Event(vals[colMap[RELAY]].c_str(),
vals[colMap[TEMPERATURE]].c_str(),
vals[colMap[TARGET_TEMPERATURE]].c_str(),
vals[colMap[HUMIDITY]].c_str(),
path.filename().string());
}
}
}
}
}
else statusReport.report("No eventlog in json");
}
void cli(Json& top, Json js, vector<string>& path) {
start:
Json::Type type = js.type();
string fullpath;
follow(top, path, &fullpath);
cout << (fullpath == "" ? "at top" : fullpath) << ": " << typetag[type] << endl;
if (type == Json::Type::OBJECT) {
int n = 0;
for (string key : js.keys()) {
Json prop = js.get(key);
cout << setw(3) << n++ << ". " << key;
if (prop.type() == Json::ARRAY)
cout << " [" << prop.size() << "]";
else if (prop.type() == Json::OBJECT)
cout << " {" << prop.size() << "}";
else
cout << ": " << prop;
cout << endl;
}
} else if (type == Json::Type::ARRAY) {
int n = 0;
for (unsigned i = 0; i < js.size(); i++) {
cout << setw(3) << n++ << ". ";
Json elem = js[i];
Json::Type eltype = elem.type();
if (eltype == Json::ARRAY)
cout << typetag[eltype] << " [" << elem.size() << "]";
else if (eltype == Json::OBJECT)
cout << typetag[eltype] << " {" << elem.size() << "}";
else
cout << elem;
cout << endl;
}
} else
cout << js << endl;
char line[1024];
do {
cout << "> ";
cin.getline(line, sizeof(line));
if (cin.eof()) {
cout << '\n';
exit(0);
}
char* p = line;
while (isspace(*p))
p++;
if (*p == 0)
continue;
if (*p == 'h' || *p == '?') {
cout << "enter a number to select an object, q to go back\n";
cout << ". : list current object\n";
cout << "p [file.json] : print out current object [into file]\n";
#ifdef WITH_SCHEMA
cout << "s file.json : load file as a json schema\n";
#endif
cout << "= text : replace current object by parsed text\n";
continue;
}
if (*p == '.')
goto start;
if (*p == 'q') {
if (!path.empty())
path.pop_back();
return;
}
if (*p == 'p') {
while (isspace(*++p));
if (*p == 0) {
cout << js << '\n';
continue;
}
ofstream out(p);
if (!out) {
cout << "cannot write to '" << p << "'\n";
continue;
}
out << js << '\n';
if (out.bad())
cout << "i/o error occured while writing\n";
out.close();
continue;
}
#ifdef WITH_SCHEMA
if (*p == 's') {
while (isspace(*++p));
if (*p == 0) {
cout << "file name expected\n";
continue;
}
ifstream ifs(p);
if (!ifs) {
cout << "cannot read " << p << '\n';
continue;
}
try {
ifs >> schema;
} catch (std::exception& ex) {
cout << "exception: " << ex.what() << '\n';
}
string reason;
if (!js.valid(schema, &reason))
cout << reason << '\n';
continue;
}
#endif
if (*p == '=') {
try {
js = Json::parse(p + 1);
if (path.empty()) {
top = js;
continue;
}
vector<string> ppath(path.begin(), path.end()-1);
Json parent = follow(top, ppath, nullptr);
if (parent.type() == Json::Type::ARRAY)
parent.replace(stoi(path.back()), js);
else
parent.set(path.back(), js);
}catch (Json::use_error& ex) {
cout << "use_error: " << ex.what() << '\n';
} catch (Json::parse_error& ex) {
cout << "parse_error: " << ex.what() << '\n';
cout << "line: " << ex.line << ", col: " << ex.col << '\n';
}
continue;
}
int n = -1;
while (isdigit(*p)) {
if (n < 0)
n = 0;
n = 10 * n + (*p++ - '0');
}
if (n < 0) {
cout << "? (type 'h' for help)\n";
continue;
}
if ((type == Json::OBJECT || type == Json::ARRAY) && n >= (int)js.size()) {
cout << "out of range\n";
continue;
}
Json next;
string name;
if (type == Json::OBJECT) {
name = js.keys()[n];
next = js[name];
} else if (type == Json::ARRAY) {
name = to_string(n);
next = js[n];
}
if (next.type() != Json::JSNULL) {
path.push_back(name);
cli(top, next, path);
goto start;
}
} while (true);
}
void SceneLoader::load_internal(const string& path, Resources& resources)
{
string pathContext = dirname(path);
std::string err;
Json jsonScene = Json::parse(resources.getText(path, Resources::NO_CACHE), err);
if (!err.empty())
panic("Failed to read scene %s: %s", path.c_str(), err.c_str());
if (jsonScene.is_object()) {
// Handle includes
if (jsonScene["include"].is_string()) {
load_internal(resolvePath(pathContext, jsonScene["include"].string_value()), resources);
} else if (jsonScene["include"].is_array()) {
for (auto& includePath : jsonScene["include"].array_items())
load_internal(resolvePath(pathContext, includePath.string_value()), resources);
}
// Parse modules
if (jsonScene["modules"].is_array() && world->has_system<ModuleSystem>()) {
world->get_system<ModuleSystem>().load(jsonScene["modules"], false);
}
// Parse environment
if (jsonScene["environment"].is_object()) {
m_environment = assign(m_environment, jsonScene["environment"]);
}
// Parse fonts
if (jsonScene["fonts"].is_object() && world->has_system<ImGuiSystem>()) {
const Json::object& fonts = jsonScene["fonts"].object_items();
ImGuiSystem& imgui = world->get_system<ImGuiSystem>();
for (auto& it : fonts) {
ASSERT(it.second.is_object());
string path = resources.findPath(resolvePath(pathContext, it.second["path"].string_value()));
float size = it.second["size"].number_value();
imgui.loadFont(it.first, path, size);
}
}
// Parse sounds
if (jsonScene["sounds"].is_object() && world->has_system<AudioSystem>()) {
const Json::object& sounds = jsonScene["sounds"].object_items();
AudioSystem& audio = world->get_system<AudioSystem>();
for (auto& it : sounds) {
if (it.second.is_string()) {
audio.add(it.first, resources.getBinary(resolvePath(pathContext, it.second.string_value())));
} else if (it.second.is_array()) {
for (auto& it2 : it.second.array_items()) {
ASSERT(it2.is_string());
audio.add(it.first, resources.getBinary(resolvePath(pathContext, it2.string_value())));
}
}
}
}
// Parse prefabs
if (jsonScene["prefabs"].is_object()) {
const Json::object& scenePrefabs = jsonScene["prefabs"].object_items();
for (auto& it : scenePrefabs)
prefabs[it.first] = it.second;
}
}
// Parse objects
const Json::array& objects = jsonScene.is_array() ? jsonScene.array_items() : jsonScene["objects"].array_items();
for (uint i = 0; i < objects.size(); ++i) {
instantiate(objects[i], resources, pathContext);
}
}
static bool _body_from_json(const Json &obj)
{
if (!obj.is_number_integer()) return false;
Body *body = Pi::game->GetSpace()->GetBodyByIndex(obj);
return push_body_to_lua(body);
}
/** If the configuration of this installation has not been reported for the
* current version, collect the hardware statistics and send it to STK's
* server.
*/
void reportHardwareStats()
{
// Version of the hw report, which is stored in the DB. If new fields
// are added, increase this version. Each STK installation will report
// its configuration only once (per version number). So if the version
// number is increased, a new report will be sent.
const int report_version = 1;
if(UserConfigParams::m_last_hw_report_version>=report_version) return;
while(UserConfigParams::m_random_identifier==0)
{
RandomGenerator rg;
UserConfigParams::m_random_identifier = rg.get(1<<30);
user_config->saveConfig();
}
Json json;
#ifdef WIN32
json.add("os_win", 1);
#else
json.add("os_win", 0);
#endif
#ifdef __APPLE__
json.add("os_macosx", 1);
#else
json.add("os_macosx", 0);
#endif
#ifdef __linux__
json.add("os_linux", 1);
json.add("os_unix", 1);
#else
json.add("os_linux", 0);
json.add("os_unix", 0);
#endif
#ifdef DEBUG
json.add("build_debug", 1);
#endif
json.add("os_version", getOSVersion());
unsigned int ogl_version = irr_driver->getGLSLVersion();
unsigned int major = ogl_version/100;
unsigned int minor = ogl_version - 100*major;
std::string version =
StringUtils::insertValues("%d.%d", major, minor);
json.add("GL_SHADING_LANGUAGE_VERSION", version);
std::string vendor, renderer, full_version;
irr_driver->getOpenGLData(&vendor, &renderer, &full_version);
json.add("GL_VENDOR", vendor );
json.add("GL_RENDERER", renderer );
json.add("GL_VERSION", full_version );
json.add("gfx_drv_ver", "OpenGL "+vendor);
std::string card_name = vendor;
if(StringUtils::startsWith(card_name, "ATI Technologies Inc."))
card_name="ATI";
else if (StringUtils::startsWith(card_name, "NVIDIA Corporation"))
card_name="NVIDIA";
else if(StringUtils::startsWith(card_name, "S3 Graphics"))
card_name="S3";
json.add("gfx_card", card_name+" "+renderer);
json.add("video_xres", UserConfigParams::m_width );
json.add("video_yres", UserConfigParams::m_height);
int mem = getRAM();
if(mem>0)
json.add("ram_total", mem);
int nr_procs = getNumProcessors();
if(nr_procs>0)
json.add("cpu_numprocs", nr_procs);
json.add("GL_EXTENSIONS", getGLExtensions());
getGLLimits(&json);
json.finish();
// ------------------------------------------------------------------------
/** A small class which sends the HW report to the STK server. On
* completion, it will either update the last-submitted-hw-report version,
* or log an error message (in which case next time STK is started it
* wil try again to log the report).
*/
class HWReportRequest : public Online::HTTPRequest
{
private:
/** Version number of the hw report. */
int m_version;
public:
HWReportRequest(int version) : Online::HTTPRequest(/*manage memory*/true, 1)
, m_version(version)
{}
// --------------------------------------------------------------------
/** Callback after the request has been executed.
*/
virtual void callback()
{
// If the request contains incorrect data, it will not have a
// download error, but return an error string as return value:
if(hadDownloadError() || getData()=="<h1>Bad Request (400)</h1>")
{
Log::error("HW report", "Error uploading the HW report.");
if(hadDownloadError())
Log::error("HW report", "%s", getDownloadErrorMessage());
else
Log::error("HW report", "%s", getData().c_str());
}
else
{
Log::info("HW report", "Upload successful.");
UserConfigParams::m_last_hw_report_version = m_version;
// The callback is executed by the main thread, so no need
// to worry about locks when writing the file.
user_config->saveConfig();
}
} // callback
}; // HWReportRequest
// ------------------------------------------------------------------------
Online::HTTPRequest *request = new HWReportRequest(report_version);
request->addParameter("user_id", UserConfigParams::m_random_identifier);
request->addParameter("time", StkTime::getTimeSinceEpoch());
request->addParameter("type", "hwdetect");
request->addParameter("version", report_version);
request->addParameter("data", json.toString());
request->setURL((std::string)UserConfigParams::m_server_hw_report+"/upload/v1/");
//request->setURL("http://127.0.0.1:8000/upload/v1/");
request->queue();
} // reportHardwareStats
int main (int argc, char *argv[]) {
google::InitGoogleLogging(argv[0]);
namespace po = boost::program_options;
vector<string> dirs;
string out_path;
string list;
size_t streams;
double file_gbs;
double container_mbs;
int resize;
int label;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message.")
("dir", po::value(&dirs), "")
("out", po::value(&out_path), "")
("streams,s", po::value(&streams)->default_value(20), "")
("file-gbs,f", po::value(&file_gbs)->default_value(4), "")
("container-mbs,c", po::value(&container_mbs)->default_value(200), "")
("resize,r", po::value(&resize)->default_value(256), "")
("label,l", po::value(&label)->default_value(0), "")
("shuffle", "")
("list", po::value(&list), "")
;
po::positional_options_description p;
p.add("out", 1);
p.add("dir", -1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).
options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help") || !out_path.size()) {
cerr << desc;
return 1;
}
vector<Line> lines;
{
Line line;
line.serial = 0;
line.label = label;
for (string const &dir: dirs) {
fs::recursive_directory_iterator it(fs::path(dir), fs::symlink_option::recurse), end;
for (; it != end; ++it) {
if (it->status().type() == fs::regular_file) {
line.path = it->path().string();
lines.push_back(line);
++line.serial;
}
}
}
LOG(INFO) << "Loaded " << lines.size() << " lines." << endl;
if (list.size()) {
ofstream os(list.c_str());
for (auto const &l: lines) {
os << l.path << '\t' << l.label << endl;
}
}
}
if (vm.count("shuffle")) {
random_shuffle(lines.begin(), lines.end());
}
Geometry geometry;
geometry.n_stream = streams;
geometry.file_size = round(file_gbs * GB);
geometry.container_size = round(container_mbs * MB);
{
boost::timer::auto_cpu_timer t;
DataSet dataset(out_path, geometry, 0);
std::atomic<unsigned> done(0);
#pragma omp parallel for
for (unsigned i = 0; i < lines.size(); ++i) {
Record rec;
string const &path = lines[i].path;
rec.meta.label = lines[i].label;
rec.meta.serial = lines[i].serial;
cv::Mat image = cv::imread(path, cv::IMREAD_COLOR);
vector<uint8_t> jpeg;
if (image.total() == 0) {
LOG(WARNING) << "fail to load image " << path;
continue;
}
if (resize) {
cv::Mat image2;
cv::resize(image, image2, cv::Size(resize, resize));
cv::imencode(".jpg", image2, jpeg);
}
Json json = Json::object {
{"fname", path},
{"ocols", image.cols},
{"orows", image.rows}
};
string extra = json.dump();
rec.image_size = jpeg.size();
rec.image = reinterpret_cast<char const *>(&jpeg[0]);
rec.extra = &extra[0];
rec.extra_size = extra.size();
#pragma omp critical
dataset << rec;
unsigned n = done.fetch_add(1);
LOG_IF(INFO, n && ((n % 1000) == 0)) << n << '/' << lines.size() << " images.";
}
}
}
JSON11_TEST_ASSERT(!err_failing_comment.empty());
std::list<int> l1 { 1, 2, 3 };
std::vector<int> l2 { 1, 2, 3 };
std::set<int> l3 { 1, 2, 3 };
JSON11_TEST_ASSERT(Json(l1) == Json(l2));
JSON11_TEST_ASSERT(Json(l2) == Json(l3));
std::map<string, string> m1 { { "k1", "v1" }, { "k2", "v2" } };
std::unordered_map<string, string> m2 { { "k1", "v1" }, { "k2", "v2" } };
JSON11_TEST_ASSERT(Json(m1) == Json(m2));
// Json literals
const Json obj = Json::object({
{ "k1", "v1" },
{ "k2", 42.0 },
{ "k3", Json::array({ "a", 123.0, true, false, nullptr }) },
});
std::cout << "obj: " << obj.dump() << "\n";
JSON11_TEST_ASSERT(obj.dump() == "{\"k1\": \"v1\", \"k2\": 42, \"k3\": [\"a\", 123, true, false, null]}");
JSON11_TEST_ASSERT(Json("a").number_value() == 0);
JSON11_TEST_ASSERT(Json("a").string_value() == "a");
JSON11_TEST_ASSERT(Json().number_value() == 0);
JSON11_TEST_ASSERT(obj == json);
JSON11_TEST_ASSERT(Json(42) == Json(42.0));
JSON11_TEST_ASSERT(Json(42) != Json(42.1));
const string unicode_escape_test =
