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 << "."); } }
void JsonArchive::DumpJsonTree(Json::Value* root, int depth) { if (root == NULL) { root = &m_Root; } depth += 1; printf( " {type=[%d], size=%d}", root->type(), root->size() ); if( root->size() > 0 ) { printf("\n"); for( Json::ValueIterator itr = root->begin() ; itr != root->end() ; itr++ ) { // Print depth. for( int tab = 0 ; tab < depth; tab++) { printf("-"); } printf(" subvalue(%s) -", itr.memberName()); DumpJsonTree( &(*itr), depth); } } else { printf(" "); PrintJsonValue(root); printf( "\n" ); } }
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 << "."); } }
Translator::Langs Translator::getLangs() const { _curlBuffer = ""; Translator::Langs langs; std::string mylang = getMyLang(); if(mylang.empty()) mylang = "en"; // default std::string url = "https://translate.yandex.net/api/v1.5/tr.json/getLangs?key="; url += getApiKey(); url += "&ui="; url += mylang; curl_easy_setopt(curl, CURLOPT_URL, url.c_str());; CURLcode res = curl_easy_perform(curl); if(res != CURLE_OK) { // error } Json::Reader reader; Json::Value root; reader.parse(_curlBuffer, root); for(Json::ValueIterator it = root["langs"].begin(); it != root["langs"].end(); it++) { langs.push_back(std::make_pair( it.key().asString(), // key (*it).asString() // value )); } return langs; }
void Com::JsonParseOrder(Order_t* order){ Json::Value root; // will contains the root value after parsing. Json::Reader reader; bool parsingSuccessful = reader.parse( buffer, root ); if ( !parsingSuccessful ) { std::cout << "Failed to parse configuration\n" << reader.getFormattedErrorMessages(); return; } order->orderId = root["order_id"].asInt(); for( Json::ValueIterator itr = root["recipe"].begin() ; itr != root["recipe"].end() ; itr++ ) { #ifdef DEBUG std::cout << itr.key().asString() << " " << *itr; #endif order->ingredients.push_back(makeIngredientItem(itr.key().asString(), (*itr).asInt())); } #ifdef DEBUG printf("parsing passed\n"); #endif }
/** * 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; }
std::map<std::string, std::string> jsonValueToAccount(Json::Value& value, const std::string& accountId) { auto idPath_ = fileutils::get_data_dir() + DIR_SEPARATOR_STR + accountId; fileutils::check_dir(idPath_.c_str(), 0700); auto detailsMap = DRing::getAccountTemplate(value[DRing::Account::ConfProperties::TYPE].asString()); for( Json::ValueIterator itr = value.begin() ; itr != value.end() ; itr++ ) { if (itr->asString().empty()) continue; if (itr.key().asString().compare(DRing::Account::ConfProperties::TLS::CA_LIST_FILE) == 0) { std::string fileContent(itr->asString()); fileutils::saveFile(idPath_ + DIR_SEPARATOR_STR "ca.key", {fileContent.begin(), fileContent.end()}, 0600); } else if (itr.key().asString().compare(DRing::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) == 0) { std::string fileContent(itr->asString()); fileutils::saveFile(idPath_ + DIR_SEPARATOR_STR "dht.key", {fileContent.begin(), fileContent.end()}, 0600); } else if (itr.key().asString().compare(DRing::Account::ConfProperties::TLS::CERTIFICATE_FILE) == 0) { std::string fileContent(itr->asString()); fileutils::saveFile(idPath_ + DIR_SEPARATOR_STR "dht.crt", {fileContent.begin(), fileContent.end()}, 0600); } else detailsMap[itr.key().asString()] = itr->asString(); } return detailsMap; }
Objects::Object::Object(Json::Value data) : self_data( data ), self_x(0), self_y(0), self_w(0), self_h(0) { Json::Value dimensions = data["dimensions"]; if ( dimensions.isObject() ) { // Coordinates are stored as doubles, but interpretted as either // pixel coordinates or fractional. If ANY dimension is a double, then // they all should be (why would you use a double coordinate otherwise?) self_coordType = Objects::NON_NORM; for ( Json::ValueIterator itr = dimensions.begin(); itr != dimensions.end(); itr ++ ) { string key = itr.key().asString(); if (dimensions[ key ] . isDouble() ) { self_coordType = Objects::NORM; break; } } self_x = dimensions["x"].asDouble(); self_y = dimensions["y"].asDouble(); } }
void ItemEquipper::deserializeEquippedItems(Json::Value& root) { Item* item; for (Json::ValueIterator it = root.begin(); it != root.end(); it++) { item = new Item(); item->deserialize(*it); _equippedItems[it.key().asInt()] = item; } }
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; }
std::list<std::string> CJSONHandler::ParseAvailLanguagesTX(std::string strJSON, bool bIsXBMCCore, std::string strURL) { Json::Value root; // will contains the root value after parsing. Json::Reader reader; std::string lang; std::list<std::string> listLangs; bool parsingSuccessful = reader.parse(strJSON, root ); if ( !parsingSuccessful ) { CLog::Log(logERROR, "CJSONHandler::ParseAvailLanguagesTX: no valid JSON data"); return listLangs; } const Json::Value langs = root; std::string strLangsToFetch; std::string strLangsToDrop; std::string strLangsBlacklisted; for(Json::ValueIterator itr = langs.begin() ; itr != langs.end() ; itr++) { lang = itr.key().asString(); if (lang == "unknown") CLog::Log(logERROR, "JSONHandler: ParseLangs: no language code in json data. json string:\n %s", strJSON.c_str()); Json::Value valu = *itr; std::string strCompletedPerc = valu.get("completed", "unknown").asString(); std::string strModTime = valu.get("last_update", "unknown").asString(); bool bLangBlacklisted = g_LCodeHandler.CheckIfLangCodeBlacklisted(lang); // we only add language codes to the list which has a minimum ready percentage defined in the xml file // we make an exception with all English derived languages, as they can have only a few srings changed if (lang.find("en_") != std::string::npos || strtol(&strCompletedPerc[0], NULL, 10) > g_Settings.GetMinCompletion()-1 || !bIsXBMCCore) { if (!bLangBlacklisted) { strLangsToFetch += lang + ": " + strCompletedPerc + ", "; listLangs.push_back(lang); g_Fileversion.SetVersionForURL(strURL + "translation/" + lang + "/?file", strModTime); } else { strLangsBlacklisted += lang + ": " + strCompletedPerc + ", "; } } else strLangsToDrop += lang + ": " + strCompletedPerc + ", "; }; CLog::Log(logINFO, "JSONHandler: ParseAvailLangs: Languages to be Fetcehed: %s", strLangsToFetch.c_str()); CLog::Log(logINFO, "JSONHandler: ParseAvailLangs: Languages to be Dropped (not enough completion): %s", strLangsToDrop.c_str()); CLog::Log(logINFO, "JSONHandler: ParseAvailLangs: Languages to be Dropped due they are blacklisted: %s",strLangsBlacklisted.c_str()); return listLangs; };
string HandlerChat::getChatId(string remitente,string destinatario){ /**Busca el chat id de la conversacion sino existe lo crea.**/ Json::Value chatsId=getChatsIdValueFromDestinatario(destinatario); string id=""; for( Json::ValueIterator itr = chatsId.begin() ; itr != chatsId.end() ; itr++ ){ if((*itr).asString()==remitente){ id=itr.key().asString(); } } return id; }
bool updateRegistry(Json::Value &jsonRoot, Json::Value &outputRoot) { bool success = true; for (Json::ValueIterator iter = jsonRoot.begin(); iter != jsonRoot.end(); iter++) { Json::Value solutionsRoot = jsonRoot.get(iter.memberName(), Json::Value()); Json::Value solutionsOutput; for(Json::ValueIterator itr = solutionsRoot["settings"].begin() ; itr != solutionsRoot["settings"].end() ; itr++ ) { bool missingValue = false; Json::Value currentOption; const char * path = solutionsRoot["options"]["path"].asCString(); const char * valueName = itr.memberName(); long valueToSet = solutionsRoot["settings"][valueName].asUInt(); wstring updatedPath = toWideChar(path); wstring updatedValueName = toWideChar(valueName); long value = -1; try { value = getDwordValue(hKeyFromString(solutionsRoot["options"]["hKey"].asCString()), updatedPath.c_str(), updatedValueName.c_str()); } catch (int exCode) { currentOption["statusCode"] = exCode; currentOption["oldValue"] = Json::Value(); currentOption["newValue"] = Json::Value(); success = false; missingValue = true; } bool valueSet = setDwordValue(hKeyFromString(solutionsRoot["options"]["hKey"].asCString()), updatedPath.c_str(), updatedValueName.c_str(), valueToSet); if (missingValue) { currentOption["oldValue"] = Json::Value(); } else { currentOption["oldValue"] = value; } try { currentOption["newValue"] = getDwordValue(hKeyFromString(solutionsRoot["options"]["hKey"].asCString()), updatedPath.c_str(), updatedValueName.c_str()); } catch (int exceptionCode) { // TODO Handle gracefully. } if (!valueSet) { success = false; currentOption["newValue"] = value; } solutionsOutput[valueName] = currentOption; } outputRoot[iter.memberName()]["results"] = solutionsOutput; } return success; }
void ofApp::record(){ ofFile newfile(ofToDataPath("coordinates.json"), ofFile::WriteOnly); string time = ofToString(ofGetElapsedTimef()); for(Json::ValueIterator i = untimedData.begin() ; i != untimedData.end(); i++) { string id = i.key().asString(); data[id][time]["position"] = untimedData[id]["position"]; data[ofToString(id)][time]["rotation"] = untimedData[id]["rotation"]; cout << data; } if (data != ofxJSONElement::null) newfile << data; sound.play(); }
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; }
void Objects::StringDisplay::update() { // Make sure repeated calls to this function don't simply add strings self_displayStrings.clear(); Json::Value strings; strings = self_data["strings"]; if (self_data["external"].isBool()) if (self_data["external"] == true) { string resource = self_data["resource"].asString(); string node = self_data["node"].asString(); strings = Resources::getResourceNode(resource, node); } //Create array of human readable strings. New entry every "self_maxLines" //lines stringstream outputStream; int lineN = 0; for (Json::ValueIterator itr = strings.begin(); itr != strings.end(); itr++) { //Stored as "key" : "value", so extract these string key = itr.key().asString(); Json::Value value = strings[key]; //buffer key and do appropriate thing for value outputStream << key << self_delimiter; if (value.type() == Json::stringValue) outputStream << value.asString(); else if (value.isNumeric()) outputStream << value.asDouble(); outputStream << "\n"; lineN++; if ( lineN == self_maxLines ) { self_displayStrings.push_back(outputStream.str()); lineN = 0; outputStream.str(""); } } //Add remaining string self_displayStrings.push_back( outputStream.str() ); }
void SiteLanguagePackage::decode_from_json_object(const Json::Value &root) { Json::Value tmp; if ( root.isObject() && root.isMember("LanguageMap") ) { const Json::Value map_LanguageMap = root["LanguageMap"]; if ( !map_LanguageMap.isNull() ) { for( Json::ValueIterator it = map_LanguageMap.begin(); it != map_LanguageMap.end(); ++it ) { std::string key = it.key().asString(); LanguageMap[key] = map_LanguageMap[key].asString(); } } } }
string HandlerChat::readChat(string chatString,string user,string messageId,string conversationId){ /**Leo la CANT_MENSAJES desde mensajeId del chat desde la vista del usuario.Actualiza los estados con los * ultimos mensajes leidos en la conversacion.**/ Json::Value chat=jsonParse.stringToValue(chatString); Json::Value lastsMessages; Json::Value lastsMessagesMsg= Json::Value(Json::arrayValue); LOG(DEBUG)<<chatString; int lastMessageRead; int lastMessageId=chat["message_id"].asInt(); if(chat["User1"].asString()==user){ lastMessageRead=chat["LastMessage2"].asInt(); chat["LastMessage1"]=0; }else{ lastMessageRead=chat["LastMessage1"].asInt(); chat["LastMessage2"]=0; } Json::Value messages=chat["Messages"]; int messageIdSearch=atoi(messageId.c_str()); for( Json::ValueIterator itr = messages.begin() ; itr != messages.end() ; itr++ ){ LOG(INFO)<<"id "<<itr.key().asString(); int currentMessageId=atoi(itr.key().asString().c_str()); int min=messageIdSearch-CANT_MESSAGES; if((currentMessageId<=messageIdSearch)&&(currentMessageId>=(min))){ Json::Value Message=*itr; if(currentMessageId>=(lastMessageId-lastMessageRead)){ Message["status"]="D"; }else{ Message["status"]="R"; } Message["message_id"]=itr.key().asString(); lastsMessagesMsg.append(Message); } } lastsMessages["messages"]=lastsMessagesMsg; int bottomMessageId=messageIdSearch-CANT_MESSAGES; if(bottomMessageId<0){ bottomMessageId=0; } lastsMessages["LastMessageId"]=bottomMessageId; string lastsMessagesString=this->jsonParse.valueToString(lastsMessages); chatString=this->jsonParse.valueToString(chat); LOG(DEBUG)<<chatString; DBtuple putChat("chat_"+conversationId,chatString); DB->put(putChat); return lastsMessagesString; }
void JsonParser::parseOptions(Json::Value &root){ LOG_DEBUG("Parsing Options."); bool foundOptions = false; // Options for( Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++ ) { std::string key = itr.key().asString(); if (key == "options") { foundOptions = true; // read all standard data int r_pixelSamples = getIntAttr("pixelsamples", *itr); int r_lightSamples = getIntAttr("lightsamples", *itr); int r_mindepth = getIntAttr("mindepth", *itr); int r_maxdepth = getIntAttr("maxdepth", *itr); int r_resolution[2]; getIntArrayAttr("resolution", *itr, 2, r_resolution); std::string r_fileName = getStringAttr("filename", *itr); r_fileName = stringTemplate(r_fileName); // TODO: check for any ones we've skipped and warn the user // TODO: handle errors gracefully // apply to globals LOG_DEBUG("Setting pixel samples to: " << r_pixelSamples); (*renderEnv->globals)[PixelSamples] = (double)r_pixelSamples; LOG_DEBUG("Setting light samples to: " << r_lightSamples); (*renderEnv->globals)[LightSamples] = (double)r_lightSamples; LOG_DEBUG("Setting min trace depth to: " << r_mindepth); (*renderEnv->globals)[MinDepth] = (double)r_mindepth; LOG_DEBUG("Setting max trace depth to: " << r_maxdepth); (*renderEnv->globals)[MaxDepth] = (double)r_maxdepth; LOG_DEBUG("Setting resolution to: " << r_resolution[0] << " * " << r_resolution[1]); (*renderEnv->globals)[ResolutionX] = r_resolution[0]; (*renderEnv->globals)[ResolutionY] = r_resolution[1]; LOG_DEBUG("Setting file output to: " << r_fileName); (*renderEnv->stringGlobals)["fileName"] = r_fileName; // We're done, so we exit out of root iterator loop LOG_DEBUG("Done parsing Options.\n"); break; } } if (!foundOptions) { LOG_WARNING("No options found in file " << filename << "."); } }
void BuyCountData::decode_from_json_object(const Json::Value &root) { Json::Value tmp; if ( root.isObject() && root.isMember("buyCountMap") ) { const Json::Value map_buyCountMap = root["buyCountMap"]; if ( !map_buyCountMap.isNull() ) { for( Json::ValueIterator it = map_buyCountMap.begin(); it != map_buyCountMap.end(); ++it ) { std::string key = it.key().asString(); buyCountMap[key] = map_buyCountMap[key].asString(); } } } }
void GetBuyedListRequestData::decode_from_json_object(const Json::Value &root) { Json::Value tmp; if ( root.isObject() && root.isMember("contentUuidMap") ) { const Json::Value map_contentUuidMap = root["contentUuidMap"]; if ( !map_contentUuidMap.isNull() ) { for( Json::ValueIterator it = map_contentUuidMap.begin(); it != map_contentUuidMap.end(); ++it ) { std::string key = it.key().asString(); contentUuidMap[key] = map_contentUuidMap[key].asString(); } } } }
void CPlayerLevels::AddLevel( const FData& level, const std::string& levelId, std::list<CLevel>& levelList ) { FData value; value = level.get("PlayerId",value); if(!value.isString()) { return; } std::string playerId(value.asString()); value = level.get("PlayerName",value); std::string playerName(value.asString()); value = level.get("PlayerSource",value); std::string playerSource(value.asString()); value = level.get("Name",value); std::string name(value.asString()); value = level.get("Data",value); std::string ldata(value.asString()); value = level.get("thumb",value); std::string lthumb(value.asString()); value = level.get("RDate",value); std::string relativeDate(value.asString()); value = level.get("SDate",value); std::string date(value.asString()); value = level.get("Plays",value); int plays = value.asInt(); value = level.get("Votes",value); int votes = value.asInt(); value = level.get("Score",value); int score = value.asInt(); value = level.get("Rating",value); float rating = value.asFloat(); value = level.get("CustomData",value); CustomData customData; Json::ValueIterator it = value.begin(); for(; it != value.end(); it++) { customData.insert(std::make_pair(it.key().asString(), (*it).asString())); } levelList.push_back( CLevel(name, playerName, playerId, playerSource, ldata, lthumb, votes, plays, rating, score, date, relativeDate, customData, levelId)); }
/* * Parse JSON match data */ void Engine::ParseSnapshotData(const std::vector<uint8_t> &data) { LOGI("Parsing snapshot data"); if (data.size() == 0) { LOGI("Game data not found"); return; } std::string str(data.begin(), data.end()); LOGI("Data: %s", str.c_str()); Json::Value root; Json::Reader reader; bool parsingSuccessful = reader.parse(str, root); if (!parsingSuccessful) { LOGI("Data parse error"); return; } std::string version = root[JSON_KEY_VERSION].asString(); if (version != JSON_VERSION) { LOGI("Data version mismatch"); return; } //Reset existing data for (int32_t i = 0; i < NUM_GAME_WORLD; ++i) for (int32_t j = 0; j < NUM_GAME_STAGES; ++j) scores_[i][j] = 0; //Level data const Json::Value levels = root[JSON_KEY_LEVELS]; Json::ValueIterator it = levels.begin(); Json::ValueIterator itEnd = levels.end(); while (it != itEnd) { std::string stage = it.key().asString(); int32_t score = (*it).asInt(); LOGI("stage:%s score:%d", stage.c_str(), score); if (map_scores_.find(stage) != map_scores_.end()) *map_scores_[stage] = score; ++it; } }
void JsonParser::parseGeometry(Json::Value &root){ LOG_DEBUG("Parsing Geometry."); bool foundGeometry = false; for( Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++ ) { std::string key = itr.key().asString(); if (key == "objects") { foundGeometry = true; // find object Json::Value objRoot = *itr; for( Json::ValueIterator objItr = objRoot.begin() ; objItr != objRoot.end() ; objItr++ ) { LOG_DEBUG("Found object: " << objItr.key().asString()); // check if we're dealing with a light or mesh std::string objType = getStringAttr("type", *objItr); if (objType == "geometry"){ std::tr1::shared_ptr<AuroraObject> geo = getGeometry(*cameraTransform, *objItr, renderEnv); objects.push_back(geo); } else if (objType == "light"){ Light* light = getLight(*cameraTransform, *objItr, (*renderEnv->globals)[LightSamples], renderEnv); lights.push_back(light); } else if (objType == "envlight"){ Light* light = getEnvLight(*cameraTransform, *objItr, (*renderEnv->globals)[LightSamples], renderEnv); lights.push_back(light); } else { LOG_WARNING("Unknown object type found: " << objType); } } // apply to globals LOG_DEBUG("Done parsing Geometry.\n"); break; } } if (!foundGeometry) { LOG_WARNING("No geometry found in file " << filename << "."); } }
void BuyedListRequestData::decode_from_json_object(const Json::Value &root) { Json::Value tmp; if ( root.isObject() && root.isMember("total") ) { tmp = root["total"]; if ( !tmp.isNull() ) { total = tmp.asString(); } } if ( root.isObject() && root.isMember("contentUuid") ) { const Json::Value map_contentUuid = root["contentUuid"]; if ( !map_contentUuid.isNull() ) { for( Json::ValueIterator it = map_contentUuid.begin(); it != map_contentUuid.end(); ++it ) { std::string key = it.key().asString(); contentUuid[key] = map_contentUuid[key].asString(); } } } if ( root.isObject() && root.isMember("buyCount") ) { const Json::Value map_buyCount = root["buyCount"]; if ( !map_buyCount.isNull() ) { for( Json::ValueIterator it = map_buyCount.begin(); it != map_buyCount.end(); ++it ) { std::string key = it.key().asString(); buyCount[key] = map_buyCount[key].asInt(); } } } }
bool cStatSerializer::LoadStatFromJSON(const Json::Value & a_In) { m_Manager->Reset(); for (Json::ValueIterator it = a_In.begin() ; it != a_In.end() ; ++it) { AString StatName = it.key().asString(); eStatistic StatType = cStatInfo::GetType(StatName); if (StatType == statInvalid) { LOGWARNING("Invalid statistic type \"%s\"", StatName.c_str()); continue; } Json::Value & Node = *it; if (Node.isInt()) { m_Manager->SetValue(StatType, Node.asInt()); } else if (Node.isObject()) { StatValue Value = Node.get("value", 0).asInt(); // TODO 2014-05-11 xdot: Load "progress" m_Manager->SetValue(StatType, Value); } else { LOGWARNING("Invalid statistic value for type \"%s\"", StatName.c_str()); } } return true; }
void BuyRequestData::decode_from_json_object(const Json::Value &root) { Json::Value tmp; if ( root.isObject() && root.isMember("afCoin") ) { tmp = root["afCoin"]; if ( !tmp.isNull() ) { afCoin = tmp.asString(); } } if ( root.isObject() && root.isMember("countAdd") ) { tmp = root["countAdd"]; if ( !tmp.isNull() ) { countAdd = tmp.asString(); } } if ( root.isObject() && root.isMember("contentUuid") ) { const Json::Value map_contentUuid = root["contentUuid"]; if ( !map_contentUuid.isNull() ) { for( Json::ValueIterator it = map_contentUuid.begin(); it != map_contentUuid.end(); ++it ) { std::string key = it.key().asString(); contentUuid[key] = map_contentUuid[key].asString(); } } } }
void JsonParser::parseShaders(Json::Value &root){ LOG_DEBUG("Parsing Shaders."); bool foundShaders = false; for( Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++ ) { std::string key = itr.key().asString(); if (key == "shaders") { foundShaders = true; // loop through shaders Json::Value objRoot = *itr; for( Json::ValueIterator objItr = objRoot.begin() ; objItr != objRoot.end() ; objItr++ ) { std::string shdName = objItr.key().asString(); LOG_DEBUG("Found shader: " << shdName); // find attribute type std::string attributeType = getStringAttr("attributetype", *objItr); if (attributeType == "color"){ Shader<Color> *newShd = getColorShader(shdName, *objItr); renderEnv->shadingEngine->registerShaderColor(shdName, newShd); } else if (attributeType == "float"){ Shader<float> *newShd = getFloatShader(shdName, *objItr); renderEnv->shadingEngine->registerShaderFloat(shdName, newShd); } else{ LOG_ERROR("Unable to parse shader for attribute type: " << attributeType); } } LOG_DEBUG("Done parsing shaders.\n"); break; } } if (!foundShaders) { LOG_WARNING("No shaders found in file " << filename << "."); } }
bool Level::ReadLevelFile(std::string path) { FileIO fio; if( !fio.LoadFile("Assets/Levels/"+path) || fio.RootKey != "Level" ) return false; Json::Value types = fio.GetChildren(fio.Root); for( Json::ValueIterator i = types.begin(); i != types.end(); ++i ) { std::string type = i.key().asString(); Entity* arch = Factory::BuildArchetype("Assets/Objects/"+type); if( arch == nullptr ) continue; Json::Value objects = (*i)["Entities"]; for( Json::ValueIterator j = objects.begin(); j != objects.end(); ++j ) { Json::Value components = *j; for( Json::ValueIterator k = components.begin(); k != components.end(); ++k ) { std::string key = k.key().asString(); } // Stores Entity name and Json value with components STATIC_LIST.push_back( std::pair<std::string,Json::Value>(type,*j) ); } } return true; }
bool util::PrintJSONTree( Json::Value &root, unsigned short depth /* = 0 */) { depth += 1; printf( " {type=[%d], size=%d}", root.type(), root.size() ); if( root.size() > 0 ) { printf("\n"); for( Json::ValueIterator itr = root.begin() ; itr != root.end() ; itr++ ) { // Print depth. for( int tab = 0 ; tab < depth; tab++) { printf("-"); } printf(" subvalue("); PrintJSONValue(itr.key()); printf(") -"); PrintJSONTree( *itr, depth); } return true; } else { printf(" "); PrintJSONValue(root); printf( "\n" ); } return true; }