Example #1
0
void JsonParser::parseMaterials(Json::Value &root){
    LOG_DEBUG("Parsing Materials.");
    bool foundMaterials = false;
    for( Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++ ) {
        std::string key = itr.key().asString();
        if (key == "materials") {
            foundMaterials = true;
            
                // loop through materials
            Json::Value objRoot = *itr;
            for( Json::ValueIterator objItr = objRoot.begin() ; objItr != objRoot.end() ; objItr++ ) {
                std::string matName = objItr.key().asString();
                LOG_DEBUG("Found material: " << matName);
                
                    // we first check if we're dealing with a light or mesh
                std::string matType = getStringAttr("type", *objItr);
                Material * mat = getMaterial(matType, matName, *objItr, renderEnv); 
            
                    // add to shading engine
                renderEnv->shadingEngine->registerMaterial(matName, mat);
            }       
            LOG_DEBUG("Done parsing materials.\n");
            break;
        }
    }
    if (!foundMaterials) {
        LOG_WARNING("No materials found in file " << filename << ".");
    }
}
Example #2
0
Terr::Terr(const Json::Value& loc,
	const Json::Value locs,
	map<string, shared_ptr<Terr>>& terrs)
	: short_name{get_val("short_name", loc).asString()}
	, display_name{get_val("display_name", loc).asString()}
	, has_center{get_val("has_center", loc).asBool()}
	, adjacent{}
	, piece{}
{
	terrs[short_name] = shared_ptr<Terr>(this); // sketchy...
	assert(terrs.find(short_name) != terrs.end());
	for(const auto& adj_val : get_val("adjacent", loc)) {
		string adj_name = adj_val.asString();
		if(terrs.find(adj_name) == terrs.end()) {
			const auto it = find_if(locs.begin(), locs.end(),
				[&adj_name](const Json::Value& t) {
					return get_val("short_name", t) == adj_name;
				});
			assert(it != locs.end());
			set_terrs(*it, locs, terrs);
			assert(terrs.find(adj_name) != terrs.end()); // TODO NDEBUG
			adjacent.push_back(terrs[adj_name]);
		}
	}
}
Example #3
0
    // TODO: Clean this one up.
inline Transform getTransformAttr(const std::string &name, Json::Value &root){
    Json::Value errorVal = Json::Value(-99999); //TODO: Very temp
    Json::Value value = root.get( name.c_str(), errorVal );
    if (value == errorVal) {
        LOG_ERROR("Can't json attribute: " << name);
    }
    Transform trans;
    if (value.size() > 0) {
        for( Json::ValueIterator trItr = value.begin() ; trItr != value.end() ; trItr++ ) {
            Json::Value t = *trItr;
            if (t.begin().key().asString() == "translate") {
                double num[3];
                int i = 0;
                Json::Value xyz = *t.begin();
                for( Json::ValueIterator xyzItr = xyz.begin() ; xyzItr != xyz.end() ; xyzItr++ ) {
                    Json::Value v = *xyzItr;
                    num[i] = v.asDouble();
                    i++;
                }
                LOG_DEBUG("Translating: " << num[0] << " " << num[1] << " " << num[2]);
                trans.translate(Vector(num[0], num[1], num[2]));
            }
            else if (t.begin().key().asString() == "scale") {
                double num[3];
                int i = 0;
                Json::Value xyz = *t.begin();
                for( Json::ValueIterator xyzItr = xyz.begin() ; xyzItr != xyz.end() ; xyzItr++ ) {
                    Json::Value v = *xyzItr;
                    num[i] = v.asDouble();
                    i++;
                }
                LOG_DEBUG("Scaling: " << num[0] << " " << num[1] << " " << num[2]);
                trans.scale(num[0], num[1], num[2]);
            }
            else if (t.begin().key().asString() == "rotateX") {
                Json::Value v = *t.begin();
                double num = v.asDouble();
                LOG_DEBUG("Rotate X: " << num);
                trans.rotateX(num);
            }
            else if (t.begin().key().asString() == "rotateY") {
                Json::Value v = *t.begin();
                double num = v.asDouble();
                LOG_DEBUG("Rotate Y: " << num);
                trans.rotateY(num);
            }                                
            else if (t.begin().key().asString() == "rotateZ") {
                Json::Value v = *t.begin();
                double num = v.asDouble();
                LOG_DEBUG("Rotate Z: " << num);
                trans.rotateZ(num);
            }                                
        }
    }
    return trans;
}
Example #4
0
bool CannyReader::readFromFile()
{
	Timer aTimer;
	std::ifstream cannyFile(srcFile);
	cannyFile.precision(20);
	if (cannyFile.is_open()) {
		std::stringstream buffer;
		buffer << cannyFile.rdbuf();

		std::string contents(buffer.str());
		cout << "Time to Read: " << aTimer.elapsed() << endl;
		aTimer.restart();

		Json::Value root;
		Json::Reader reader;
		bool parsingSuccessful = reader.parse( contents, root );
		cout << "Time to parse: " << aTimer.elapsed() << endl;
		aTimer.restart();
		if (parsingSuccessful)
		{
			for( Json::ValueIterator outer = root.begin() ; outer != root.end() ; outer++ ) {
				int camNum = outer.key().asInt();

				Json::Value oneCam = root[camNum];

				for( Json::ValueIterator itr = oneCam.begin() ; itr != oneCam.end() ; itr++ ) {
					vector<Line_Segment *>* lineSegments = new vector<Line_Segment *>();

					int key = atoi(itr.key().asCString());

					Json::Value jsonSegments = oneCam[itr.key().asCString()];
					for( Json::ValueIterator itr2 = jsonSegments.begin() ; itr2 != jsonSegments.end() ; itr2++ ) {
						Json::Value jsonSeg = jsonSegments[itr2.key().asInt()];
						Line_Segment* seg = (Line_Segment *) malloc(sizeof(Line_Segment));
						seg->row1 = jsonSeg["r1"].asInt();
						seg->col1 = jsonSeg["c1"].asInt();
						seg->row2 = jsonSeg["r2"].asInt();
						seg->col2 = jsonSeg["c2"].asInt();

						lineSegments->push_back(seg);
					}
					precomputedCannySegments[camNum][key] = lineSegments;
				}
			}
			cannyFile.close();
			cout << "Time to reconstruct: " << aTimer.elapsed() << endl;

			return true;
		}
		else {
			return false;
		}
	}
	return false;
}
Example #5
0
// Recursive function to convert JSON --> Lua table
static bool push_json_value_helper(lua_State *L, const Json::Value &value,
		int nullindex)
{
	switch(value.type()) {
		case Json::nullValue:
		default:
			lua_pushvalue(L, nullindex);
			break;
		case Json::intValue:
			lua_pushinteger(L, value.asInt());
			break;
		case Json::uintValue:
			lua_pushinteger(L, value.asUInt());
			break;
		case Json::realValue:
			lua_pushnumber(L, value.asDouble());
			break;
		case Json::stringValue:
			{
				const char *str = value.asCString();
				lua_pushstring(L, str ? str : "");
			}
			break;
		case Json::booleanValue:
			lua_pushboolean(L, value.asInt());
			break;
		case Json::arrayValue:
			lua_newtable(L);
			for (Json::Value::const_iterator it = value.begin();
					it != value.end(); ++it) {
				push_json_value_helper(L, *it, nullindex);
				lua_rawseti(L, -2, it.index() + 1);
			}
			break;
		case Json::objectValue:
			lua_newtable(L);
			for (Json::Value::const_iterator it = value.begin();
					it != value.end(); ++it) {
#ifndef JSONCPP_STRING
				const char *str = it.memberName();
				lua_pushstring(L, str ? str : "");
#else
				std::string str = it.name();
				lua_pushstring(L, str.c_str());
#endif
				push_json_value_helper(L, *it, nullindex);
				lua_rawset(L, -3);
			}
			break;
	}
	return true;
}
Example #6
0
std::list<std::string> CJSONHandler::ParseResources(std::string strJSON)
{
  Json::Value root;   // will contains the root value after parsing.
  Json::Reader reader;
  std::string resName;
  std::list<std::string> listResources;

  bool parsingSuccessful = reader.parse(strJSON, root );
  if ( !parsingSuccessful )
  {
    CLog::Log(logERROR, "JSONHandler: Parse resource: no valid JSON data");
    return listResources;
  }

  for(Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++)
  {
    Json::Value valu = *itr;
    resName = valu.get("slug", "unknown").asString();

    if (resName.size() == 0 || resName == "unknown")
      CLog::Log(logERROR, "JSONHandler: Parse resource: no valid JSON data while iterating");
    listResources.push_back(resName);
    CLog::Log(logINFO, "JSONHandler: found resource on Transifex server: %s", resName.c_str());
  };
  CLog::Log(logINFO, "JSONHandler: Found %i resources at Transifex server", listResources.size());
  return listResources;
};
Example #7
0
std::map<std::string, CLangcodes> CJSONHandler::ParseTransifexLanguageDatabase(std::string strJSON)
{
  Json::Value root;   // will contains the root value after parsing.
  Json::Reader reader;
  std::string lang;

  bool parsingSuccessful = reader.parse(strJSON, root );
  if ( !parsingSuccessful )
  {
    CLog::Log(logERROR, "JSONHandler: ParseTXLanguageDB: no valid JSON data");
  }

  std::map<std::string, CLangcodes> mapTXLangs;

  const Json::Value JLangs = root;

  for(Json::ValueIterator itr = JLangs.begin() ; itr !=JLangs.end() ; itr++)
  {
    Json::Value JValu = *itr;
    const Json::Value JFields =JValu.get("fields", "unknown");

    CLangcodes LangData;
    LangData.Langcode = JFields.get("code", "unknown").asString();
    LangData.Langname = JFields.get("name", "unknown").asString();
    LangData.Pluralform = JFields.get("pluralequation", "unknown").asString();
    LangData.nplurals = JFields.get("nplurals", 0).asInt();
    if (LangData.Langcode != "unknown" && LangData.Langname != "unknown")
      mapTXLangs[LangData.Langcode] = LangData;
    else
      CLog::Log(logWARNING, "JSONHandler: ParseTXLanguageDB: corrupt JSON data found while parsing Language Database from Transifex");
  };
  return mapTXLangs;
};
Example #8
0
void JsonParser::parseCamera(Json::Value &root){
    LOG_DEBUG("Parsing Camera.");
    bool foundCamera = false;    
        // Options
    for( Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++ ) {
        std::string key = itr.key().asString();
        if (key == "renderCam") {
            foundCamera = true;
            
                // read all standard data
            double r_fieldOfView = getDoubleAttr("fov", *itr);
            Transform r_transform = getTransformAttr("transforms", *itr);

                // TODO: check for any ones we've skipped and warn the user
            
                // TODO: handle errors gracefully
            
                // apply read data
            (*renderEnv->globals)[FieldOfView] = r_fieldOfView;
            cameraTransform = new Transform(r_transform);

            LOG_DEBUG("Done parsing Camera.\n");
            break;
        }
    }
    if (!foundCamera) {
        LOG_WARNING("No render camera found in file " << filename << ".");
    }
}
	static void buildWaypointList(WaypointClient* userdata)
	{
		WaypointClient* anInstance = (WaypointClient*) userdata;
		Fl_Input_Choice * fromWPChoice = anInstance->frWps;
		Fl_Input_Choice * toWPChoice = anInstance->toWps;

		fromWPChoice->clear();
		toWPChoice->clear();
		Json::Value waypointsArray = anInstance->getWaypoints().get("waypoints",0);
		if (waypointsArray.size() == 0)
		{
			fromWPChoice->add("EMPTY");
			toWPChoice->add("EMPTY");
		}
		else
		{
			for (Json::ValueIterator itr = waypointsArray.begin(); itr != waypointsArray.end(); itr++)
			{
				Json::Value waypoint = *itr;
				string name = waypoint["name"].asString();
				fromWPChoice->add(name.c_str());
				toWPChoice->add(name.c_str());
			}

		}
		fromWPChoice->value(0);
		toWPChoice->value(0);
		SelectedFromWP(NULL, anInstance);
	}
Example #10
0
bool cInventory::LoadFromJson(Json::Value & a_Value)
{
	int SlotIdx = 0;
	
	for (Json::Value::iterator itr = a_Value.begin(); itr != a_Value.end(); ++itr, SlotIdx++)
	{
		cItem Item;
		Item.FromJson(*itr);
		
		// The JSON originally included the 4 crafting slots and the result slot, so we need to skip the first 5 items:
		if (SlotIdx < 5)
		{
			continue;
		}
		
		// If we loaded all the slots, stop now, even if the JSON has more:
		if (SlotIdx - 5 >= invNumSlots)
		{
			break;
		}
		
		int GridSlotNum = 0;
		cItemGrid * Grid = GetGridForSlotNum(SlotIdx - 5, GridSlotNum);
		ASSERT(Grid != nullptr);
		Grid->SetSlot(GridSlotNum, Item);
	}  // for itr - a_Value[]
	return true;
}
Example #11
0
Manifest DappLoader::loadManifest(std::string const& _manifest)
{
	/// https://github.com/ethereum/go-ethereum/wiki/URL-Scheme
	Manifest manifest;
	Json::Reader jsonReader;
	Json::Value root;
	jsonReader.parse(_manifest, root, false);

	Json::Value entries = root["entries"];
	for (Json::ValueIterator it = entries.begin(); it != entries.end(); ++it)
	{
		Json::Value const& entryValue = *it;
		std::string path = entryValue["path"].asString();
		if (path.size() == 0 || path[0] != '/')
			path = "/" + path;
		std::string contentType = entryValue["contentType"].asString();
		std::string strHash = entryValue["hash"].asString();
		if (strHash.length() == 64)
			strHash = "0x" + strHash;
		h256 hash = jsToFixed<32>(strHash);
		unsigned httpStatus = entryValue["status"].asInt();
		manifest.entries.push_back(ManifestEntry{ path, hash, contentType, httpStatus });
	}
	return manifest;
}
Example #12
0
/**
 * Read a map of {list_name : class_list} from json
 */
std::unordered_map<std::string, std::vector<std::string> > ConfigFiles::load_class_lists() {
  std::unordered_map<std::string, std::vector<std::string> > lists;
  std::string class_lists_filename;
  this->m_json.get("class_lists", "", class_lists_filename);

  if (class_lists_filename.empty()) {
    return lists;
  }

  std::ifstream input(class_lists_filename);
  Json::Reader reader;
  Json::Value root;
  bool parsing_succeeded = reader.parse(input, root);
  always_assert_log(parsing_succeeded, "Failed to parse class list json from file: %s\n%s",
                    class_lists_filename.c_str(),
                    reader.getFormattedErrorMessages().c_str());

  for (Json::ValueIterator it = root.begin(); it != root.end(); ++it) {
    std::vector<std::string> class_list;
    Json::Value current_list = *it;
    for (Json::ValueIterator list_it = current_list.begin(); list_it != current_list.end(); ++list_it) {
      lists[it.key().asString()].push_back((*list_it).asString());
    }
  }

  lists["secondary_dex_head.list"] = get_coldstart_classes();

  return lists;
}
Example #13
0
qpid::types::Variant::List agocontrol::jsonToVariantList(Json::Value value) {
	Variant::List list;
	try {
		for (Json::ValueIterator it = value.begin(); it != value.end(); it++) {
			if ((*it).size() > 0) {
				// cout << "JSON Type: " << (*it).type() << endl;
				if ((*it).type() == 6) {
					list.push_back(jsonToVariantList((*it)));
				} else if ((*it).type() == 7) {
					list.push_back(jsonToVariantMap((*it)));
				}
			} else {
				if ((*it).isString()) list.push_back( (*it).asString());
				if ((*it).isBool()) list.push_back( (*it).asBool());
				if ((*it).isInt()) list.push_back( (*it).asInt());
				if ((*it).isUInt()) list.push_back( (*it).asUInt());
				if ((*it).isDouble()) list.push_back( (*it).asDouble());
			}
		}
	} catch (const std::exception& error) {
                cout << "ERROR! Exception during JSON->Variant::Map conversion!" << endl;
                stringstream errorstring;
                errorstring << error.what();
		cout << "EXCEPTION: " << errorstring.str() << endl;
        }


	return list;
}
Example #14
0
int Response::getMsgList(std::string &s, std:: vector <msgRecord> &vmr) const {
    Json::Value root;
    stringToJson(s, root);
    try {
        Json::Value json = root["result"][0U]["value"];
        for (int i = 0; i != json.size(); i++) {
            Json::Value temp = json[i];
            int srcID, targetID, postTime, msgType;
            std::string msgText;
            for (__typeof(temp.begin()) it = temp.begin(); it != temp.end(); it++) {
                if (it.key().asString() == "srcID")
                    srcID = (*it).asInt();
                else if (it.key().asString() == "targetID")
                    targetID = (*it).asInt();
                else if (it.key().asString() == "msgText")
                    msgText = (*it).asString();
                else if (it.key().asString() == "postTime")
                    postTime = (*it).asInt();
                else if (it.key().asString() == "msgType")
                    msgType = (*it).asInt();
            }
            MsgRecord mr(srcID, targetID, msgText, msgType);
            mr.postTime = postTime;
            vmr.push_back(mr);
        }
    } catch (...) {
        return ERROR;
    }
    return 0;
}
Example #15
0
  int load_config(const char *cfg_root)
  {
    Json::Value root;
    if (this->load_json_cfg(cfg_root, SKILL_CFG_PATH, root) != 0)
      return -1;

    for (int i = CAREER_LI_LIANG; i <= CAREER_ZHI_LI; ++i)
      this->career_skill_map_.insert(i, new ilist<int>());

    for(Json::Value::iterator iter = root.begin();
        iter != root.end();
        ++iter)
    {
      int cid = ::atoi(iter.key().asCString());
      if (!clsid::is_skill(cid))
      {
        e_log->error("%d is not skill in %s!", cid, SKILL_CFG_PATH);
        return -1;
      }
      skill_cfg_obj *sco = new skill_cfg_obj();
      this->skill_cfg_obj_map_.insert(std::make_pair(cid, sco));
      if (this->load_json(*iter, sco, cid) != 0)
        return -1;

      if (clsid::is_char_skill(cid)
          && util::is_career_ok(sco->career_))
        this->career_skill_map_.find(sco->career_)->push_back(cid);
    }
    return 0;
  }
Example #16
0
Model *ResourceManager::loadModel(const Json::Value& value,
                                  const std::unordered_map<std::string, ResPtr<Resource> >& externalResources)
{
    Json::Value lods = getMember(value, "lods");

    if (not lods.isArray())
    {
        throw std::runtime_error("Unable to get the LODs.");
    }

    Model *model = NEW(Model);

    if (value.isMember("stippledLODs"))
    {
        model->mStippledLODs = value["stippledLODs"].asBool();
    }

    for (Json::Value::iterator it = lods.begin(); it != lods.end(); ++it)
    {
        Json::Value lod = *it;

        std::string mesh = getMember(lod, "mesh").asString();
        std::string material = getMember(lod, "material").asString();
        float distance = getMember(lod, "distance").asFloat();

        model->mLODs.push_back(LOD(externalResources.at(mesh).cast<Mesh>(),
                                   externalResources.at(material).cast<Material>(),
                                   distance));
    }

    model->sortLODs();

    return model;
}
/** 
* Deserialize JSON formatted skeleton sequence
*/
void SkeletonRepresentationSequenceJSON::Deserialize(Json::Value& root)
{
	this->version = root.get("version", 0).asDouble();
	size_t frameCount = root.get("frameCount", 0).asUInt();

	Json::Value skeletonSequence = root.get("skeletonSequence", Json::nullValue);

	if (frameCount == 0 || skeletonSequence.isNull())
	{
		root = Json::nullValue;
		return;
	}
	else
	{
		size_t index = 0;
		for (Json::ValueIterator it = skeletonSequence.begin(); it != skeletonSequence.end(); it++)
		{
			if ((*it).isNull()) continue;

			// get pose set for current frame
			SkeletonRepresentationJSON skeletonFrame;
			skeletonFrame.Deserialize(*it);

			push_back(skeletonFrame);
			index++;
		}
	}
}
/** 
* Deserialize set of skeletons
*/
void SkeletonRepresentationSetJSON::Deserialize(Json::Value& root)
{
	// de-serialize primitives
	m_version = root.get("version",0).asDouble();
	m_frameNumber = root.get("frameNumber",0).asInt();
	m_timeStamp = root.get("timeStamp",0).asDouble();

	size_t skeletonCount = root.get("skeletonCount",0).asUInt();

	// we only use the first skeleton (index = 0) from the data
	//m_v.assign(skeletonCount, PoseRepresentationPoints());

	Json::Value skeletonArray = root.get("skeletons", Json::nullValue);

	if (!skeletonArray.isNull())
	{
		size_t index = 0;
		for (Json::ValueIterator it = skeletonArray.begin(); it != skeletonArray.end(); it++)
		{
			if (index > 1) break;	/// here, we quit after reading the zero index

			if ((*it).isNull()) continue;


			index++;
		}
	}

}
Example #19
0
static HMENU menuFromJson(const Json::Value& menuInfo) {
	if (menuInfo.isArray()) {
		HMENU menu = ::CreatePopupMenu();
		for (auto it = menuInfo.begin(); it != menuInfo.end(); ++it) {
			const Json::Value& item = *it;
			UINT id = item.get("id", 0).asUInt();
			std::wstring text = utf8ToUtf16(item.get("text", "").asCString());

			UINT flags = MF_STRING;
			if (id == 0 && text.empty())
				flags = MF_SEPARATOR;
			else {
				if (item.get("checked", false).asBool())
					flags |= MF_CHECKED;
				if (!item.get("enabled", true).asBool())
					flags |= MF_GRAYED;

				const Json::Value& subMenuValue = item.get("submenu", Json::nullValue);
				if (subMenuValue.isArray()) {
					HMENU submenu = menuFromJson(subMenuValue);
					flags |= MF_POPUP;
					id = UINT_PTR(submenu);
				}
			}
			AppendMenu(menu, flags, id, text.c_str());
		}
		return menu;
	}
	return NULL;
}
Example #20
0
  int load_config(const char *cfg_root)
  {
    Json::Value root;
    if (this->load_json_cfg(cfg_root, JING_JI_AWARD_CFG_PATH, root) != 0)
      return -1;

    for (Json::Value::iterator iter = root.begin();
         iter != root.end();
         ++iter)
    {
      int id = ::atoi(iter.key().asCString());
      if (id >= MAX_AWARD_KIND_COUNT) return -1;

      jj_award_obj *jao = new jj_award_obj();
      this->jj_award_obj_map_.insert(id, jao);

      jao->rank_min_     = (*iter)["rank_min"].asInt();
      jao->rank_max_     = (*iter)["rank_max"].asInt();
      jao->bind_diamond_ = (*iter)["bind_zuanshi"].asInt();
      jao->coin_         = (*iter)["coin"].asInt();
      jao->ji_fen_       = (*iter)["ji_fen"].asInt();
    }

    return 0;
  }
bool MatchStart::parse(std::string json) {
    Json::Reader reader;
    Json::Value  root;

    if (!reader.parse(json, root, false)) {
        throw std::invalid_argument("Unable to parse json");
    }

    romingSettings.parse(root.get("roamingSettings", Json::nullValue));
    clientVersionFromXml = root.get("clientVersionFromXml", Json::nullValue).asString();
    clientVersionFromExe = root.get("clientVersionFromExe", Json::nullValue).asString();
    mapDisplayName       = root.get("mapDisplayName", Json::nullValue).asString();
    gameplayID           = root.get("gameplayID", Json::nullValue).asString();
    regionCode           = root.get("regionCode", Json::nullValue).asString();
    playerID             = root.get("playerID", Json::nullValue).asUInt();
    serverName           = root.get("serverName", Json::nullValue).asString();
    Json::Value vehiclesRoot = root.get("vehicles", Json::nullValue);
    if (vehiclesRoot.size() > 0) {
        for (auto it = vehiclesRoot.begin(); it != vehiclesRoot.end(); it++) {
            std::string key(it.memberName());
            Json::Value vehicleRoot = vehiclesRoot.get(key, Json::nullValue);
            Vehicle     value;
            value.parse(vehicleRoot);
            vehicles.insert(std::make_pair(key, value));
        }
    }
    dateTime      = root.get("dateTime", Json::nullValue).asString();
    mapName       = root.get("mapName", Json::nullValue).asString();
    playerName    = root.get("playerName", Json::nullValue).asString();
    battleType    = root.get("battleType", Json::nullValue).asUInt();
    playerVehicle = root.get("playerVehicle", Json::nullValue).asString();
    return true;
}
Example #22
0
qpid::types::Variant::Map agocontrol::jsonToVariantMap(Json::Value value) {
	Variant::Map map;
	try {
		for (Json::ValueIterator it = value.begin(); it != value.end(); it++) {
			// printf("%s\n",it.key().asString().c_str());
			// printf("%s\n", (*it).asString().c_str());
			if ((*it).size() > 0) {
				// cout << "JSON Type: " << (*it).type() << endl;
				// cout << "Key: " << it.key().asString() << endl;
				if ((*it).type() == 6) {
					map[it.key().asString()] = jsonToVariantList((*it));
				} else if ((*it).type() == 7) {
					map[it.key().asString()] = jsonToVariantMap((*it));
				}
			} else {
				if ((*it).isString()) map[it.key().asString()] = (*it).asString();
				if ((*it).isBool()) map[it.key().asString()] = (*it).asBool();
				if ((*it).isInt()) map[it.key().asString()] = (*it).asInt();
				if ((*it).isUInt()) map[it.key().asString()] = (*it).asUInt();
				if ((*it).isDouble()) map[it.key().asString()] = (*it).asDouble();
			}
		}	
	} catch (const std::exception& error) {
		cout << "ERROR! Exception during JSON->Variant::Map conversion!" << endl;
		stringstream errorstring;
		errorstring << error.what();
		cout << "EXCEPTION: " << errorstring.str() << endl;
	}
	return map;
}
Example #23
0
bool PlayingCards::JsonDeserialization(const std::string &sJsonPlayingCards, std::string &sErrorMessage)
{
    Json::Reader jReader;
    Json::Value  jCards;
    Json::Value  jCard;
    Card cCard;

    if (jReader.parse(sJsonPlayingCards, jCards, false))
    {
        m_vCards.clear();

        for (Json::ValueIterator it = jCards.begin(); it != jCards.end(); ++it)
        {
            jCard = (*it);
            if (cCard.JsonDeserialization(jCard.toStyledString(), sErrorMessage))
            {
                m_vCards.push_back(cCard);
            }
            else
            {
                return false;
            }
        }

        return true;
    }
    else
    {
        sErrorMessage = jReader.getFormattedErrorMessages();
        return false;
    }
}
Example #24
0
static bool menuFromJson(ITfMenu* pMenu, const Json::Value& menuInfo) {
	if (pMenu != nullptr && menuInfo.isArray()) {
		for (Json::Value::const_iterator it = menuInfo.begin(); it != menuInfo.end(); ++it) {
			const Json::Value& item = *it;
			UINT id = item.get("id", 0).asUInt();
			std::wstring text = utf8ToUtf16(item.get("text", "").asCString());
			
			DWORD flags = 0;
			Json::Value submenuInfo;
			ITfMenu* submenu = nullptr;
			if (id == 0 && text.empty())
				flags = TF_LBMENUF_SEPARATOR;
			else {
				if (item.get("checked", false).asBool())
					flags |= TF_LBMENUF_CHECKED;
				if (!item.get("enabled", true).asBool())
					flags |= TF_LBMENUF_GRAYED;

				submenuInfo = item["submenu"];  // FIXME: this is a deep copy. too bad! :-(
				if (submenuInfo.isArray()) {
					flags |= TF_LBMENUF_SUBMENU;
				}
			}
			pMenu->AddMenuItem(id, flags, NULL, NULL, text.c_str(), text.length(), flags & TF_LBMENUF_SUBMENU ? &submenu : nullptr);
			if (submenu != nullptr && submenuInfo.isArray()) {
				menuFromJson(submenu, submenuInfo);
			}
		}
		return true;
	}
	return false;
}
// Deserialization constructor
VertexAttributes::VertexAttributes(const Json::Value& value)
    : vertexAttributesFrameSize(0)
{
    // We first need to validate that this a Json array
    if(!value.isArray())
    {
        throw std::runtime_error("VertexAttributes::VertexAttributes(const Json::Value& value) - value must be an array");
    }
    
    // Iterate through all the Json values
    for(Json::Value::const_iterator it = value.begin(); it != value.end(); it++)
    {
        // The vertex attribute must be a string
        if(!(*it).isString())
        {
            throw std::runtime_error("VertexAttributes::VertexAttributes(const Json::Value& value) - serialized vertex attributes must be strings");
        }
        
        // Get the vertex attribute
        std::string vertexAttribute = (*it).asString();
        
        // Add this attribute by its key
        addVertexAttributeByStorageKey(vertexAttribute);
    }
}
Example #26
0
bool CTestjsoncpp::test_Parse()
{
	std::wstring wstrJson = ReleaseJsonStr();
	std::string strJson = wstr2str(wstrJson, CP_UTF8);
	Json::Reader jsonReader;
	Json::Value root;
	jsonReader.parse(strJson, root);

	std::string strresult = root["result"].asString();
	std::cout << "result:" << strresult << std::endl;

	std::cout << "data:" << std::endl;
	Json::Value jvData = root["data"];
	if(jvData.isArray())
	{
		std::cout << "[" << std::endl;
		//item
		for (Json::Value::iterator it = jvData.begin(); it != jvData.end(); ++it)
		{
			std::cout << "{" << std::endl;
			Json::Value item = *it;
			Json::Value::Members memItem = item.getMemberNames();
			//mem in item
			for (Json::Value::Members::iterator itItem = memItem.begin(); itItem != memItem.end(); ++itItem)
			{
				std::string strKey = *itItem;
				std::string strValue = item[strKey].asString();
				std::cout << strKey << ":" << strValue << std::endl;
			}
			std::cout << "}" << std::endl;
		}
		std::cout << "]" << std::endl;
	}
	return false;
}
Example #27
0
int SData::ParseEPG(Json::Value &parsed, time_t iStart, time_t iEnd, int iChannelNumber, ADDON_HANDLE handle)
{
  XBMC->Log(LOG_DEBUG, "%s", __FUNCTION__);

  time_t iStartTimestamp;
  time_t iStopTimestamp;
  int iEntriesTransfered(0);

  for (Json::Value::iterator it = parsed.begin(); it != parsed.end(); ++it) {
    iStartTimestamp = Utils::GetIntFromJsonValue((*it)["start_timestamp"]);
    iStopTimestamp = Utils::GetIntFromJsonValue((*it)["stop_timestamp"]);

    if (!(iStartTimestamp > iStart && iStopTimestamp < iEnd)) {
      continue;
    }

    EPG_TAG tag;
    memset(&tag, 0, sizeof(EPG_TAG));

    tag.iUniqueBroadcastId = Utils::GetIntFromJsonValue((*it)["id"]);
    tag.strTitle = (*it)["name"].asCString();
    tag.iChannelNumber = iChannelNumber;
    tag.startTime = iStartTimestamp;
    tag.endTime = iStopTimestamp;
    tag.strPlot = (*it)["descr"].asCString();

    PVR->TransferEpgEntry(handle, &tag);
    iEntriesTransfered++;
  }
  
  return iEntriesTransfered;
}
Example #28
0
bool cBeaconEntity::LoadFromJson(const Json::Value & a_Value)
{
	m_PosX = a_Value.get("x", 0).asInt();
	m_PosY = a_Value.get("y", 0).asInt();
	m_PosZ = a_Value.get("z", 0).asInt();

	Json::Value AllSlots = a_Value.get("Slots", 0);
	int SlotIdx = 0;
	for (Json::Value::iterator itr = AllSlots.begin(); itr != AllSlots.end(); ++itr)
	{
		cItem Item;
		Item.FromJson(*itr);
		SetSlot(SlotIdx, Item);
		SlotIdx++;
	}

	m_BeaconLevel = (char)a_Value.get("Level", 0).asInt();
	int PrimaryEffect = a_Value.get("PrimaryEffect", 0).asInt();
	int SecondaryEffect = a_Value.get("SecondaryEffect", 0).asInt();

	if ((PrimaryEffect >= 0) && (PrimaryEffect <= (int)cEntityEffect::effSaturation))
	{
		m_PrimaryEffect = (cEntityEffect::eType)PrimaryEffect;
	}

	if ((SecondaryEffect >= 0) && (SecondaryEffect <= (int)cEntityEffect::effSaturation))
	{
		m_SecondaryEffect = (cEntityEffect::eType)SecondaryEffect;
	}

	return true;
}
Example #29
0
void CompareJson(json::Value& lhs, json::Value& rhs, json::Value& output) {
  std::string lstr, rstr;
  if (rhs.type() != lhs.type()) return;
  switch (lhs.type()) {
  case json::Value::tString:
    lstr = lhs.getString();
    rstr = rhs.getString();
    if (!lstr.empty() && lstr[0] == '$' && lstr.back() == '$') {
      size_t slash = lstr.find('/');
      std::string cat = lstr.substr(1, slash - 1);
      std::string name = lstr.substr(slash + 1, lstr.length() - slash - 2);
      output[cat][name] = rstr;
    }
    break;
  case json::Value::tArray:
    for (size_t i = 0; i < lhs.length(); ++i) {
      if (i < rhs.length()) {
        CompareJson(lhs[i], rhs[i], output);
      }
    }
    break;
  case json::Value::tObject:
    for (auto it = lhs.begin(); it != lhs.end(); ++it) {
      if (rhs.has(it.key())) {
        CompareJson(*it, rhs[it.key()], output);
      }
    }
    break;
  }
}
Example #30
0
void ImportProfileCommand::importKeys(const Json::Value &keys, const Serializer &serializer, KeyStore &store)
{
    for(Json::Value::const_iterator it = keys.begin(), end = keys.end(); it!=end; ++it)
    {
        store.insert(serializer.unserialize(*it));
    }
}