Exemple #1
0
int CCardFieldDlg::load_card_right_json()
{
	int i,idx;
	Json::Value root;
	Json::Reader reader;
	std::ifstream input;
	//input.open("e:\\works\\cardlib\\ykt.v3_1.dev\\bin\\lcsmanager\\cardright.json");
	input.open((LPCTSTR)m_jsonfile);
	if(input.is_open()==false)
	{
		AfxMessageBox("´ò¿ªÅäÖÃÎļþ´íÎó");
		return -1;
	}
	if(reader.parse(input,root)==false)
	{
		std::string msg = "¶ÁÈ¡ÅäÖÃÎļþ´íÎó : " + reader.getFormatedErrorMessages();
		AfxMessageBox(msg.c_str());
		return -1;
	}
	std::string encoding = root.get("encoding","GBK").asString();
	Json::Value fields = root["cardfield"];
	Json::Value::Members fldid = fields.getMemberNames();
	m_cardfield.clear();
	for(i = 0;i < fldid.size();++i)
	{
		idx = atoi(fldid[i].c_str());
		std::string v = fields.get(fldid[i],"Unknown").asString();
		m_cardfield.insert(CARD_FILED_MAP::value_type(idx,v));
	}
	if(fldid.size() > m_string_len)
		m_string_len = fldid.size();
//	std::sort(m_cardfield.begin(),m_cardfield.end());
	init_check_box();
	return 0;
}
Exemple #2
0
//virtual 
bool AnimationLogic::init(  const JsonValueRef json )
{
	m_states.clear();

	if( !json.isMember("states") || !json.isMember("events") ) return false;

	for( int i=0; i< json["events"].size(); i++)
	{
		m_events.push_back( json["events"][i].asString() );
	}

	m_defaultState = json.get("default", "idle").asString();

	Json::Value::Members states = json["states"].getMemberNames();
	for(int i=0; i< states.size(); i++)
	{
		JsonValueRef stateObj = json["states"][states[i]];
		Json::Value::Members events = stateObj.getMemberNames();

		AnimState animState;
		animState.name = states[i];
		CCLOG(" animState: %s", animState.name.c_str() );
		for( int j=0; j< events.size(); j++)
		{
			std::string newState = stateObj[ events[j] ].asString();
			animState.transitionTable[ events[j] ] = newState;

			CCLOG("  %s => %s", events[j].c_str(), newState.c_str() );
		}

		m_states[ states[i] ] = animState;
	}

	return true;
}
Exemple #3
0
  //Load skin
  bool Skin::load(const std::string& filename) {
    std::ifstream ifs(filename);
    std::string str((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());

    Json::Value root;
    Json::Reader reader;

    m_classes.clear();

    if (!reader.parse(str, root)) {
      return false;
    }

    Json::Value::Members classes = root.getMemberNames();
    for (uint32 i = 0; i < classes.size(); i++) {
      std::string name = classes[i];
      Json::Value v = root[name];

      Skin::SkinClass sc;

      bool addP = false;

      //We need to figure out if we're dealing with sub classes.
      Json::Value::Members subs = v.getMemberNames();
      for (uint32 j = 0; j < subs.size(); j++) {
        if (subs[j] != "normal" && subs[j] != "hover" && subs[j] != "active" && subs[j] != "focus") {
          //Yup, this is a sub class.
          Skin::SkinClass sub;
          jsonToStates(v[subs[j]], sub);

          sc.m_subs.insert(ClassMapPair(subs[j], sub));

        } else {
          addP = true;
        }
      }

      //There's a valid state in the root
      if (addP) {
        jsonToStates(v, sc);
      }

      sc.reset();
      m_classes.insert(ClassMapPair(name, sc));
    }

    m_loaded = filename;

    return true;
  }
  void Configuration::SetupRegisteredUsers(MongooseServer& httpServer)
  {
    boost::mutex::scoped_lock lock(globalMutex_);

    httpServer.ClearUsers();

    if (!configuration_.isMember("RegisteredUsers"))
    {
      return;
    }

    const Json::Value& users = configuration_["RegisteredUsers"];
    if (users.type() != Json::objectValue)
    {
      LOG(ERROR) << "Badly formatted list of users";
      throw OrthancException(ErrorCode_BadFileFormat);
    }

    Json::Value::Members usernames = users.getMemberNames();
    for (size_t i = 0; i < usernames.size(); i++)
    {
      const std::string& username = usernames[i];
      std::string password = users[username].asString();
      httpServer.RegisterUser(username.c_str(), password.c_str());
    }
  }
  static void RegisterUserContentType()
  {
    if (configuration_.isMember("UserContentType"))
    {
      const Json::Value& parameter = configuration_["UserContentType"];

      Json::Value::Members members = parameter.getMemberNames();
      for (size_t i = 0; i < members.size(); i++)
      {
        std::string info = "\"" + members[i] + "\" = " + parameter[members[i]].toStyledString();
        LOG(INFO) << "Registering user-defined attachment type: " << info;

        if (!parameter[members[i]].asBool())
        {
          LOG(ERROR) << "Not a number in this user-defined attachment type: " << info;
          throw OrthancException(ErrorCode_BadParameterType);
        }

        int contentType = parameter[members[i]].asInt();

        try
        {
          RegisterUserContentType(contentType, members[i]);
        }
        catch (OrthancException&)
        {
          LOG(ERROR) << "Cannot register this user-defined attachment type: " << info;
          throw;
        }
      }
    }
  }
Exemple #6
0
void QueryParser::buildTasks(
    const Json::Value &query,
    std::vector<std::shared_ptr<Task> > &tasks,
    task_map_t &task_map) const {
    Json::Value::Members members = query["operators"].getMemberNames();
    std::string papiEventName = getPapiEventName(query);
    for (unsigned i = 0; i < members.size(); ++i) {
        Json::Value planOperationSpec = query["operators"][members[i]];
        std::string typeName = planOperationSpec["type"].asString();
        std::shared_ptr<PlanOperation> planOperation = QueryParser::instance().parse(
                    typeName, planOperationSpec);
        planOperation->setEvent(papiEventName);
        setInputs(planOperation, planOperationSpec);
        if (auto para = std::dynamic_pointer_cast<ParallelizablePlanOperation>(planOperation)) {
            para->setPart(planOperationSpec["part"].asUInt());
            para->setCount(planOperationSpec["count"].asUInt());
        } else {
            if (planOperationSpec.isMember("part") || planOperationSpec.isMember("count")) {
                throw std::runtime_error("Trying to parallelize " + typeName + ", which is not a subclass of Parallelizable");
            }
        }

        planOperation->setOperatorId(members[i]);
        if (planOperationSpec.isMember("core"))
            planOperation->setPreferredCore(planOperationSpec["core"].asInt());
        // check for materialization strategy
        if (planOperationSpec.isMember("positions"))
            planOperation->setProducesPositions(!planOperationSpec["positions"].asBool());
        tasks.push_back(planOperation);
        task_map[members[i]] = planOperation;
    }
}
Exemple #7
0
void readJson() {
    using namespace std;
    std::string strValue = "{\"name\":\"json\",\"array\":[{\"cpp\":\"jsoncpp\",\"cpp1\":\"jxx\"},{\"java\":\"jsoninjava\"},{\"php\":\"support\"}]}";

    Json::Reader reader;
    Json::Value value;

    if (reader.parse(strValue, value))
    {
        std::string out = value["name"].asString();
        //std::cout << out << std::endl;
        const Json::Value arrayObj = value["array"];

        for (int i=0; i<arrayObj.size(); i++) {
            const Json::Value::Members memberNames = arrayObj[i].getMemberNames();
            for(int j=0; j<memberNames.size(); j++) {
                std::cout << memberNames[j] << std::endl;
            }
        }
        //for (unsigned int i = 0; i < arrayObj.size(); i++)
        //{
        //if (!arrayObj[i].isMember("cpp"))
        //    continue;
        //out = arrayObj[i].asString();
        //std::cout << out;
        //if (i != (arrayObj.size() - 1))
        //    std::cout << std::endl;
        //std::cout << "1111" << std::endl;
        //}
    }
}
Exemple #8
0
bool KsCardMsg::parseJsonData(const std::string& rootname,Json::Value &root)
{
	size_t i;
	Json::Value::Members mbs = root.getMemberNames();
	++parseLevel_;
	if(parseLevel_>2)
		return false;
	for(i = 0;i < mbs.size(); ++i)
	{
		Json::Value& clt = root[mbs[i]];
		std::string fullname = rootname;
		if(rootname.length() > 0)
			 fullname += ".";
		fullname += mbs[i];
		if(clt.isArray() || clt.isObject())
		{
			if(!parseJsonData(fullname,clt))
				return false;
		}
		else
		{
			msg_field_.insert(PARA_MAP_TYPE::value_type(fullname,root.get(mbs[i],"").asString()));
		}
	}
	return true;
}
int jsonParse(string _s)
{
    // Let's parse it
    Json::Value root;
    Json::Reader reader;
    bool parsedSuccess = reader.parse(_s,
                                      root,
                                      false);

    if (not parsedSuccess) {
        // Report failures and their locations
        // in the document.
        cout << "Failed to parse JSON" << endl
             << reader.getFormatedErrorMessages()
             << endl;
        return 1;
    }

    Json::Value::Members mem = root.getMemberNames();
    Json::Value child = root[mem[0]];
    cout << "name: " << mem[0] << ", child: " << child.asString() << endl;
    for (int i = 1; i < mem.size(); ++i)
    {
        child = root[mem[i]];
        cout << "name: " << mem[i] << endl;
        Json::Value::Members childMem = child.getMemberNames();
        cout << "\t" << "type: " << child[childMem[0]].asString() << endl;
        cout << "\t" << "value: " << child[childMem[1]].asString() << endl;
        cout << "\t" << "typeGen: " << child[childMem[2]].asString() << endl;
    }
    return 1;
}
Exemple #10
0
    void SimplifyTags(Json::Value& target,
                      const Json::Value& source,
                      DicomToJsonFormat format)
    {
      assert(source.isObject());

      target = Json::objectValue;
      Json::Value::Members members = source.getMemberNames();

      for (size_t i = 0; i < members.size(); i++)
      {
        const Json::Value& v = source[members[i]];
        const std::string& type = v["Type"].asString();

        std::string name;
        switch (format)
        {
          case DicomToJsonFormat_Human:
            name = v["Name"].asString();
            break;

          case DicomToJsonFormat_Short:
            name = members[i];
            break;

          default:
            throw OrthancException(ErrorCode_ParameterOutOfRange);
        }

        if (type == "String")
        {
          target[name] = v["Value"].asString();
        }
        else if (type == "TooLong" ||
                 type == "Null")
        {
          target[name] = Json::nullValue;
        }
        else if (type == "Sequence")
        {
          const Json::Value& array = v["Value"];
          assert(array.isArray());

          Json::Value children = Json::arrayValue;
          for (Json::Value::ArrayIndex i = 0; i < array.size(); i++)
          {
            Json::Value c;
            SimplifyTags(c, array[i], format);
            children.append(c);
          }

          target[name] = children;
        }
        else
        {
          assert(0);
        }
      }
    }
void LevelsParser::parseEntity(const Json::Value& json, Entity* entity) {
  using namespace Json;
  Json::Value::Members members = json.getMemberNames();
  
  for (int i = 0; i < members.size(); ++i) {
    String member = members[i];
    shared_ptr<EntityParser> parser = EntityParser::parser(member);
    Json::Value data = json[parser->type().c_str()];
    parser->parse(entity, data);
  }
}
Exemple #12
0
void readJsonDict() {
    std::string strValue = "{\"a\":\"1\",\"b\":\"2\",\"c\":\"3\"}";
    Json::Reader reader;
    Json::Value value;
    reader.parse(strValue, value);
    std::cout << "value.isObject=" << value.isObject() << std::endl;
    const Json::Value::Members memberNames = value.getMemberNames();
    for(int i=0; i<memberNames.size(); i++) {
        std::cout << memberNames[i] << ":" << value[memberNames[i]] << std::endl;
    }
}
Exemple #13
0
void JsonManager::initFromFile( const std::string& fileName )
{
	Json::Value json = ReadFileToJson(fileName);
	if( json.isObject() ) {
		Json::Value::Members domains = json.getMemberNames();
		for(int i=0; i< domains.size(); i++){
			m_domains[ domains[i] ] = json[domains[i]];
			CCLog("loaded json domain %s", domains[i].c_str() );
		}
	}
}
	void DbgPrintValue( const Json::Value& value )
	{
		const Json::Value::Members valueMembers = value.getMemberNames();
		const UINT numMembers = valueMembers.size();
		for( UINT i = 0; i < numMembers; i++ )
		{
			const Json::Value& member = valueMembers[i];
			const std::string s = member.toStyledString();
			DBGOUT( "\t%s\n", s.c_str() );
			//DBGOUT( "\t%s\n", member.c_str() );
		}
	}
Json::Value& QueryTransformationEngine::transform(Json::Value& query) {
  Json::Value::Members operatorIds = query["operators"].getMemberNames();
  Json::Value operatorConfiguration;
  for (size_t i = 0; i < operatorIds.size(); ++i) {
    operatorConfiguration = query["operators"][operatorIds[i]];
    // check whether operator should be transformed; postpone transformation if dynamic transformation is required
    if (operatorConfiguration["dynamic"].asBool() == false &&
        _factory.count(operatorConfiguration["type"].asString()) > 0)
      _factory[operatorConfiguration["type"].asString()]->transform(operatorConfiguration, operatorIds[i], query);
    // check whether operator needs to be parallelized
    if (requestsParallelization(operatorConfiguration))
      applyParallelizationTo(operatorConfiguration, operatorIds[i], query);
  }
  // std::cout << query.toStyledString()<< std::endl;
  return query;
}
Exemple #16
0
//////////////////////////////////////////////////////////////////////////
// addAllPackageCrossRefs
void CsPackageImporter::addAllPackageCrossRefs( Json::Value& Root )
{
	std::lock_guard< std::recursive_mutex > Lock( BuildingLock_ );
	BcAssert( BuildingBeginCount_ > 0 );

	// If it's a string value, attempt to match it.
	if( Root.type() == Json::stringValue )
	{
		std::cmatch Match;
		std::regex_match( Root.asCString(), Match, GRegex_ResourceReference );
		
		// Try the weak match.
		// TODO: Merge into  regex.
		if( Match.size() == 0 )
		{
			std::regex_match( Root.asCString(), Match, GRegex_WeakResourceReference );
		}

		if( Match.size() == 4 )
		{
			BcU32 RefIndex = addPackageCrossRef( Root.asCString() );

			// If we find it, replace string reference with a cross ref index.
			if( RefIndex != BcErrorCode )
			{
				PSY_LOG("Adding crossref %u: %s\n", RefIndex, Root.asCString() );
				Root = Json::Value( RefIndex );
			}
		}
	}
	else if( Root.type() == Json::arrayValue )
	{
		for( BcU32 Idx = 0; Idx < Root.size(); ++Idx )
		{
			addAllPackageCrossRefs( Root[ Idx ] );
		}
	}
	else if( Root.type() == Json::objectValue )
	{
		Json::Value::Members MemberValues = Root.getMemberNames();

		for( BcU32 Idx = 0; Idx < MemberValues.size(); ++Idx )
		{
			addAllPackageCrossRefs( Root[ MemberValues[ Idx ] ] );
		}
	}
}
Exemple #17
0
void FBDialogLookupNgw::httpSelectedFinished ()
{
    if (httpSelectedReply->error() == QNetworkReply::NoError)
    {
        if (!receivedJson.empty())
        {
            Json::Reader json_reader;
            Json::Value json_root;
            if (json_reader.parse(receivedJson, json_root, false))
            {
                Json::Value json_items = json_root["lookup_table"]["items"];
                Json::Value::Members mems = json_items.getMemberNames();

                selectedLookup.clear();
                for (int i=0; i<mems.size(); i++)
                {
                    QString strName = QString::fromUtf8(mems[i].data());
                    QString strValue = QString::fromUtf8(json_items[mems[i]]
                                                        .asString().data());
                    selectedLookup.append(QPair<QString,QString>(strName,strValue));
                }

                wLabelStatus->setText(tr("Connection successful"));
                httpSelectedReply->deleteLater();

                this->accept();

                return; // TODO: do we need return here?
            }
            else
            {
                wLabelStatus->setText(tr("Error reading JSON"));
            }
        }
        else
        {
            wLabelStatus->setText(tr("Error reading JSON"));
        }
    }
    else
    {
        wLabelStatus->setText(tr("Connection error"));
    }

    receivedJson = "";
    httpSelectedReply->deleteLater();
}
int ThreadUsuario::onJoinGame(Json::Value& data, Json::Value& userData){
	int ret = 0;
	Logger::log("["+this->myId+"] Evento Join game");
	Value retMsj;
	retMsj["event"] = EVENT_JOIN_GAME;
	retMsj["msj"] = "Error";
	retMsj["code"] = -1;
	if(this->partida){
		retMsj["msj"] = "Ya estas conectado a una partida";
		retMsj["code"] = 1;
	}else{
		string id = data["id"].asString();
		long id_n;
		stringstream ss(id);
		ss >> id_n;

		PartidaInterface* part = this->server->connectPartidas(id_n);

		if (part){
			if (part->getEstado() != PARTIDA_ABIERTA){
				retMsj["msj"] = "Partida no esta en estado abierta";
			}else if (part->getUsuarios() >= part->getMaxUsuarios()){
				retMsj["msj"] = "Partida llena";
			}else{
				Json::Value::Members keys = userData.getMemberNames();
				Json::Value yo;
				for(int i=0; i < keys.size(); i++){
					if(keys[i] != string("pass"))
						yo[keys[i]] = userData[keys[i]];
				}

				this->partida = part;
				part->addUsuario(this, yo);
				retMsj["msj"] = "Coneccion correcta";
				retMsj["code"] = 0;
			}
		}
	}

	if (this->write(retMsj)){
		Logger::log("["+this->myId+"] Error escribiendo el mensaje de conexion"
				"de partida");
		return 1;
	}
	return ret;
}
Exemple #19
0
  void SimplifyTags(Json::Value& target,
                    const Json::Value& source)
  {
    assert(source.isObject());

    target = Json::objectValue;
    Json::Value::Members members = source.getMemberNames();

    for (size_t i = 0; i < members.size(); i++)
    {
      const Json::Value& v = source[members[i]];
      const std::string& name = v["Name"].asString();
      const std::string& type = v["Type"].asString();

      if (type == "String")
      {
        target[name] = v["Value"].asString();
      }
      else if (type == "TooLong" ||
               type == "Null")
      {
        target[name] = Json::nullValue;
      }
      else if (type == "Sequence")
      {
        const Json::Value& array = v["Value"];
        assert(array.isArray());

        Json::Value children = Json::arrayValue;
        for (Json::Value::ArrayIndex i = 0; i < array.size(); i++)
        {
          Json::Value c;
          SimplifyTags(c, array[i]);
          children.append(c);
        }

        target[name] = children;
      }
      else
      {
        assert(0);
      }
    }
  }
  static void AddFileToConfiguration(const boost::filesystem::path& path)
  {
    LOG(WARNING) << "Reading the configuration from: " << path;

    Json::Value config;

    {
      std::string content;
      Toolbox::ReadFile(content, path.string());

      Json::Value tmp;
      Json::Reader reader;
      if (!reader.parse(content, tmp) ||
          tmp.type() != Json::objectValue)
      {
        LOG(ERROR) << "The configuration file does not follow the JSON syntax: " << path;
        throw OrthancException(ErrorCode_BadJson);
      }

      Toolbox::CopyJsonWithoutComments(config, tmp);
    }

    if (configuration_.size() == 0)
    {
      configuration_ = config;
    }
    else
    {
      Json::Value::Members members = config.getMemberNames();
      for (Json::Value::ArrayIndex i = 0; i < members.size(); i++)
      {
        if (configuration_.isMember(members[i]))
        {
          LOG(ERROR) << "The configuration section \"" << members[i] << "\" is defined in 2 different configuration files";
          throw OrthancException(ErrorCode_BadFileFormat);          
        }
        else
        {
          configuration_[members[i]] = config[members[i]];
        }
      }
    }
  }
  static void CreateDicom(RestApiPostCall& call)
  {
    // curl http://localhost:8042/tools/create-dicom -X POST -d '{"PatientName":"Hello^World"}'
    // curl http://localhost:8042/tools/create-dicom -X POST -d '{"PatientName":"Hello^World","PixelData":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3gUGDDcB53FulQAAAElJREFUGNNtj0sSAEEEQ1+U+185s1CtmRkblQ9CZldsKHJDk6DLGLJa6chjh0ooQmpjXMM86zPwydGEj6Ed/UGykkEM8X+p3u8/8LcOJIWLGeMAAAAASUVORK5CYII="}'

    Json::Value replacements;
    if (call.ParseJsonRequest(replacements) && replacements.isObject())
    {
      ParsedDicomFile dicom;

      Json::Value::Members members = replacements.getMemberNames();
      for (size_t i = 0; i < members.size(); i++)
      {
        const std::string& name = members[i];
        std::string value = replacements[name].asString();

        DicomTag tag = FromDcmtkBridge::ParseTag(name);
        if (tag == DICOM_TAG_PIXEL_DATA)
        {
          dicom.EmbedImage(value);
        }
        else
        {
          dicom.Replace(tag, value);
        }
      }

      DicomInstanceToStore toStore;
      toStore.SetParsedDicomFile(dicom);

      std::string id;
      StoreStatus status = OrthancRestApi::GetContext(call).Store(id, toStore);

      if (status == StoreStatus_Failure)
      {
        LOG(ERROR) << "Error while storing a manually-created instance";
        return;
      }

      OrthancRestApi::GetApi(call).AnswerStoredInstance(call, id, status);
    }
  }
void PrefabEntityParser::parse(Entity* entity, const Json::Value& node) {
  String path = node.asString();
  String fullPath = CCFileUtils::fullPathFromRelativePath(path.c_str());
  String json = String::fromFile(fullPath);
  
  Json::Reader reader;
  Json::Value root;
  
  reader.parse(json.str(), root);
  
  Json::Value::Members members = root.getMemberNames();
  
  for (int i = 0; i < members.size(); ++i) {
    shared_ptr<EntityParser> parser = EntityParser::parser(members[i]);
    Json::Value data = root[parser->type().c_str()];
    parser->parse(entity, data);
  }
  
  entity->prefabOverride();
}
  static void ParseReplacements(DicomModification& target,
                                const Json::Value& replacements)
  {
    if (!replacements.isObject())
    {
      throw OrthancException(ErrorCode_BadRequest);
    }

    Json::Value::Members members = replacements.getMemberNames();
    for (size_t i = 0; i < members.size(); i++)
    {
      const std::string& name = members[i];
      std::string value = replacements[name].asString();

      DicomTag tag = FromDcmtkBridge::ParseTag(name);
      target.Replace(tag, value);

      VLOG(1) << "Replace: " << name << " " << tag << " == " << value << std::endl;
    }
  }
void SpellDiagramNode::createModSlotMenu( RadialLayer* slotEquipMenu, CCPoint pos, int idx )
{
	
		m_slotEquipMenu->setCenterNode(createPentNode(MOD_COLOR, ccc4f(0,0,0,1)));
		m_slotEquipMenu->setPosition( pos );
		addChild(m_slotEquipMenu);

		CCLabelTTF* label = CCLabelTTF::create("cancel", "Arial",20);
		m_slotEquipMenu->addItem(label, "slotMenuCancel");

		Json::Value::Members modNames = m_spellParts_Mods.getMemberNames();
		for( int i=0; i<modNames.size(); i++)
		{
			label = CCLabelTTF::create(modNames[i].c_str(), "Helvetica", 20.0f);
			Json::Value data;
			data["name"] = modNames[i];
			data["idx"] = idx;
			m_slotEquipMenu->addItemWithJson(label, "slotMenuMod", data);
		}

}
int ThreadUsuario::onNewGame(Json::Value& data, Json::Value& userData){
	Value retMsj;
	int ret = 0;
	retMsj["event"] = EVENT_NEW_GAME;
	retMsj["msj"] = "Error";
	retMsj["code"] = 1;

	if (this->partida){
		retMsj["msj"] = "Ya estas conectado a una partida";
		retMsj["code"] = 1;
	}else{
		if (! data["nivel"].isNumeric()) {
			// TODO: Error
		}

		int nivel = data["nivel"].asInt();

		if(nivel > userData["nivel"].asInt()){
			retMsj["msj"] = "Tu nivel es bajo";
		}else{
			retMsj["msj"] = "Conectado satisfactoriamnte";
			retMsj["code"] = 0;
			Json::Value::Members keys = userData.getMemberNames();
				Json::Value yo;
				for(int i=0; i < keys.size(); i++){
					if(keys[i] != string("pass"))
						yo[keys[i]] = userData[keys[i]];
				}
			std::string nombre = data["nombre"].asString();
			this->partida = this->server->newPartida(nivel, nombre);
			this->partida->addUsuario(this, yo);
		}
	}

	if (this->write(retMsj)){
		Logger::log("["+this->myId+"] Error escribiendo el mensaje de nueva partida");
		return 1;
	}
	return ret;
}
  static bool ReadKeys(std::set<std::string>& target,
                       const char* parameter,
                       bool onlyAlphanumeric)
  {
    boost::mutex::scoped_lock lock(globalMutex_);

    target.clear();
  
    if (!configuration_.isMember(parameter))
    {
      return true;
    }

    const Json::Value& modalities = configuration_[parameter];
    if (modalities.type() != Json::objectValue)
    {
      LOG(ERROR) << "Bad format of the \"DicomModalities\" configuration section";
      throw OrthancException(ErrorCode_BadFileFormat);
    }

    Json::Value::Members members = modalities.getMemberNames();
    for (size_t i = 0; i < members.size(); i++)
    {
      if (onlyAlphanumeric)
      {
        for (size_t j = 0; j < members[i].size(); j++)
        {
          if (!isalnum(members[i][j]) && members[i][j] != '-')
          {
            return false;
          }
        }
      }

      target.insert(members[i]);
    }

    return true;
  }
Exemple #27
0
// Return list of values in object
void JsonValue::methodGetMemberNames( tThreadData* pThreadData, qshort pParamCount ) {
    // Create return value
    EXTfldval fValReturn, fValMember, fValColName;

    // Create single column list
    EXTqlist *retList = new EXTqlist( listVlen );

    getEXTFldValFromString(fValColName, "Member");
    str255 colName;
    fValColName.getChar(colName, qtrue);
    retList->addCol(fftCharacter, dpFcharacter, 10000000, &colName);

    // Ensure that the Json::Value is an Object (since those are the only one's with member names)
    if ( !(jsonValue->isObject()) ) {
        fValReturn.setList(retList, qtrue, qfalse);
        ECOaddParam(pThreadData->mEci, &fValReturn);
        return;
    }

    Json::Value::Members memberNames = jsonValue->getMemberNames();

    // Loop the member names to create the list
    std::string rowMember;
    for (qlong lineNumber = 0; lineNumber < static_cast<qlong>(memberNames.size()); lineNumber++) {

        retList->insertRow(0);
        //retList->setCurRow( lineNumber+1 );
        retList->getColValRef(lineNumber+1, 1, fValMember, qtrue);

        // Retrieve member name and place it in the list
        rowMember = memberNames[lineNumber];
        getEXTFldValFromString(fValMember, rowMember);
    }

    fValReturn.setList(retList, qtrue, qfalse);
    ECOaddParam(pThreadData->mEci, &fValReturn);
    return;
}
static bool ParseFromJsonValue(const Json::Value& root, Message* pb) {
    std::string pb_type = pb->GetTypeName();
    VLOG(20) << "Set info for type:" << pb_type;

    Json::Value::Members members = root.getMemberNames();
    for (size_t i = 0; i < members.size(); ++i) {
        VLOG(21) << "Member:" << members[i];
        const std::string& field_name = members[i];
        Json::Value sub_node;
        sub_node = root.get(field_name, sub_node);
        if (sub_node.isNull()) {
            const FieldDescriptor* field = pb->GetDescriptor()->FindFieldByName(field_name);
            if (field && field->is_required()) {
                LOG(ERROR) << "Missing required field:" << field_name;
                return false;
            }
        } else {
            if (!SetValueForMessage(field_name, sub_node, pb)) {
                return false;
            }
        }
    }
    return true;
}
Exemple #29
0
bool AnimatedSprite::loadTrackFile(const std::string& file, const std::string& name, std::shared_ptr<Library> &lib)
{
	std::ifstream sfile(file.c_str());
	if (!sfile.is_open()) {
		Guy::printLog("Error loading %s anim file", file.c_str());
		return false;
	}

	Json::Value root;
	Json::Reader reader;
	if (!reader.parse(sfile, root) ) {
		Guy::printLog("Failed to parse %s anim file, reason: %s", file.c_str(), reader.getFormatedErrorMessages().c_str());
		return false;
	}

	Track track;
	track.frameCount = root.get("frameCount", "UTF-8" ).asUInt();
	const Json::Value keyframes = root["keyFrames"];
	for ( int index = 0; index < keyframes.size(); ++index )
	{
		Keyframe key;
		const Json::Value keyframe = keyframes[index];
		const Json::Value data = keyframe["data"];
		key.frame = keyframe.get("frame", "UTF-8").asUInt();
		key.filename = data.get("fileName", "UTF-8").asString();
		Guy::TextureManager::instance().getTexture(key.filename);

		const Json::Value offset = data["offset"];
		key.origin.x = -offset.get("x", "UTF-8").asDouble();
		key.origin.y = -offset.get("y", "UTF-8").asDouble();

		{
			const Json::Value rect = data["rect"];
			const Json::Value bottomRight = rect["bottomRight"];
			const Json::Value topLeft     = rect["topLeft"];

			key.rect.update(math::vec2i(bottomRight.get("x", "UTF-8").asInt(), bottomRight.get("y", "UTF-8").asInt()));
			key.rect.update(math::vec2i(    topLeft.get("x", "UTF-8").asInt(),     topLeft.get("y", "UTF-8").asInt()));
		}

		{
			const Json::Value custom = data["customProperties"];
			Json::Value::Members members = custom.getMemberNames();
			for(std::size_t i; i < members.size(); ++i) {
				if (members[i] == std::string("velx"))
				{
					key.acceleration.x = custom.get("velx", "UTF-8").asDouble();
					key.useAsVelocity = true;
				}
				else if (members[i] == std::string("vely"))
				{
					key.acceleration.y = custom.get("vely", "UTF-8").asDouble();
					key.useAsVelocity = true;
				}
				else if (members[i] == std::string("accx"))
				{
					key.acceleration.x = custom.get("accx", "UTF-8").asDouble();
					key.useAsVelocity = false;
				}
				else if (members[i] == std::string("accy"))
				{
					key.acceleration.y = custom.get("accy", "UTF-8").asDouble();
					key.useAsVelocity = false;
				}
				else if (members[i] == std::string("frix"))
				{
					key.friction.x = custom.get("frix", "UTF-8").asDouble();
				}
				else if (members[i] == std::string("friy"))
				{
					key.friction.y = custom.get("friy", "UTF-8").asDouble();
				}
				else if (members[i] == std::string("maxx"))
				{
					key.maxVel.x = custom.get("maxx", "UTF-8").asDouble();
				}
				else if (members[i] == std::string("maxy"))
				{
					key.maxVel.y = custom.get("maxy", "UTF-8").asDouble();
				}
			}
		}

		const Json::Value hitBoxes = data["hitBoxes"];
		for ( int index = 0; index < hitBoxes.size(); ++index )
		{
			const Json::Value hitBox = hitBoxes[index];
			const Json::Value rect = hitBox["rect"];
			const Json::Value bottomRight = rect["bottomRight"];
			const Json::Value topLeft     = rect["topLeft"];

			math::bbox3i box;
			box.update(math::vec3i(bottomRight.get("x", "UTF-8").asInt(), bottomRight.get("y", "UTF-8").asInt(), -100));
			box.update(math::vec3i(    topLeft.get("x", "UTF-8").asInt(),     topLeft.get("y", "UTF-8").asInt(),  100));

			if (hitBox.get("group", "UTF-8").asString() == std::string("body")) {
				key.body.push_back(box);
			}
			if (hitBox.get("group", "UTF-8").asString() == std::string("damage")) {
				key.damage.push_back(box);
			}
		}

		track.keyframes.push_back(key);
	}

	lib->trackNames.insert(std::make_pair(name, lib->tracks.size()));
	lib->tracks.push_back(track);

	return true;
}
Exemple #30
0
//////////////////////////////////////////////////////////////////////////
// internalImportObject
BcBool CsCore::internalImportObject( const Json::Value& Object, CsResourceRef<>& Handle, CsDependancyList* pDependancyList, BcBool ForceImport )
{
	BcScopedLock< BcMutex > Lock( ContainerLock_ );

	// If we pass in a string value, call into the importResource that takes a file name.
	// If we pass in an object value, load it from that.
	if( Object.type() == Json::stringValue )
	{
		// We don't pass the dependancy list in if it's a file.
		return internalImportResource( Object.asString(), Handle, NULL, ForceImport );
	}
	else if( Object.type() == Json::objectValue )
	{
		Json::Value::Members Members = Object.getMemberNames();
		
		if( Members.size() == 1 )
		{
			const std::string& Type = Members[ 0 ];
			const Json::Value& Resource = Object[ Type ];
			
			// If the resource is a string, it's an alias - so we need to load the appropriate file.
			// If the resource is an object, then do appropriate loading.
			if( Resource.type() == Json::stringValue )
			{
				return internalImportResource( Resource.asString(), Handle, pDependancyList, ForceImport );
			}
			else if( Resource.type() == Json::objectValue )
			{
				// Check the resource has a name, and it's a string.
				if( Resource.isMember( "name" ) && Resource[ "name" ].type() == Json::stringValue )
				{ 
					// Import resource by string.
					const std::string& Name = Resource[ "name" ].asString();
				
					// Check name is a valid length.
					// TODO: Check it only contains valid characters.
					if( Name.length() > 0 )
					{
						// Create a file writer for resource (using full name!)
						CsFile* pFile = createFileWriter( getResourceFullName( Name, Type ) );

						if( pFile != NULL )
						{
							// Add name as first string.
							pFile->addString( Name.c_str() );

							// Allocate resource.
							Handle = allocResource( Name, Type, pFile );
						
							if( Handle.isValid() )
							{							
								// Import the resource immediately (blocking operation).
								if( Handle->import( Resource, *pDependancyList ) )
								{
									BcBool Success = pFile->save();
									BcAssertMsg( Success, "Failed to save out \"%s\"", getResourceFullName( Name, Type ).c_str() );
									if( Success )
									{
										// Now we need to request the resource, this will delete the imported
										// one and replace it with a valid loaded resource.
										internalRequestResource( Name, Type, Handle );
									}
								}	
								else
								{
									// Failed to import, so set handle to NULL to release it.
									Handle = NULL;
								}
							}
							else
							{
								delete pFile;
								BcPrintf( "CsCore: Can not allocate resource type %s.\n", Type.c_str() );
							}
						}
						else
						{
							BcPrintf( "CsCore: Can not allocate file writer.\n" );
						}	
					}
					else
					{
						BcPrintf( "CsCore: Json object does not contain valid name.\n" );
					}
				}
				else
				{
					BcPrintf( "CsCore: Json object does not contain name.\n" );
				}
			}
			else
			{
				BcPrintf( "CsCore: Json object is neither an alias or valid resource.\n" );
			}
		}
		else
		{
			BcPrintf( "CsCore: Json object contains more than 1 element.\n" );
		}
	}
	else
	{
		BcPrintf( "CsCore: Invalid Json object.\n" );		
	}
	return Handle.isValid();
}