C++ StyledWriter::write方法代码示例

std::string RechargeRequestData::encode(bool readable)
{
    Json::Value root = encode_to_json_object();
    if ( readable )
    {
        Json::StyledWriter writer;
        return writer.write(root);
    }
    else
    {
        Json::FastWriter writer;
        return writer.write(root);
    }
}

 string JobCodec::encode(const Job& job)
 {
     Json::Value root;
     Json::StyledWriter writer;
     
     root["uid"] = job.uid();
     root["data"] = job.data();
     root["status"] = job.status();
     root["status_description"] = job.status_description();
     root["run_at"] = (int)job.run_at();
     root["timestamp"] = (int)job.timestamp();
     
     return writer.write(root);
 }

int main(int argc, char** argv)
{ 
// ---- create from scratch ----

Json::Value fromScratch;
Json::Value array;
array.append("hello");
array.append("world");
fromScratch["hello"] = "world";
fromScratch["number"] = 2;
fromScratch["array"] = array;
fromScratch["object"]["hello"] = "world";

output(fromScratch);

// write in a nice readible way
Json::StyledWriter styledWriter;
std::cout << styledWriter.write(fromScratch);

// ---- parse from string ----

// write in a compact way
Json::FastWriter fastWriter;
std::string jsonMessage = fastWriter.write(fromScratch);

Json::Value parsedFromString;
Json::Reader reader;
bool parsingSuccessful = reader.parse(jsonMessage, parsedFromString);
if (parsingSuccessful)
{
    std::cout << styledWriter.write(parsedFromString) << std::endl;
}



  return 0;
}

BOOL SessionLayout::_displayMsgToIE(IN MessageEntity msg ,IN CString jsInterface)
{
	module::UserInfoEntity userInfo;
	if (!module::getUserListModule()->getUserInfoBySId(msg.talkerSid, userInfo))
	{
		return FALSE;
	}

	Json::Value root;
	root["name"] = util::cStringToString(userInfo.getRealName());
	root["avatar"] = userInfo.getAvatarPathWithoutOnlineState();
	root["msgtype"] = msg.msgRenderType;
	root["uuid"] = msg.talkerSid;
	CString csContent = util::stringToCString(msg.content);
	ReceiveMsgManage::getInstance()->parseContent(csContent, FALSE, GetWidth(), !msg.isMySendMsg());
	root["content"] = util::cStringToString(csContent);
	if (msg.isMySendMsg())
	{
		root["mtype"] = "me";
	}
	else
	{
		root["mtype"] = "other";
	}
	CTime timeData(msg.msgTime);
	root["time"] = util::cStringToString(timeData.Format(_T("%Y-%m-%d %H:%M:%S")));
	Json::StyledWriter styleWrite;
	std::string record = styleWrite.write(root);
	Json::Reader jsonRead;
	Json::Value rootRead;
	CString jsData = _T("[]");
	if (!jsonRead.parse(record, rootRead) || rootRead.isNull())
	{
		CString csError = util::stringToCString(record, CP_UTF8);
		APP_LOG(LOG_INFO, TRUE, _T("json parse error:%s"), csError);
		jsData = _T("[]");
		return FALSE;
	}
	else
		jsData = util::stringToCString(record, CP_UTF8);
	//调用页面的JS代码
	if (m_pWebBrowser)
	{
		VARIANT VarResult;
		m_pWebBrowser->CallJScript(jsInterface.GetBuffer(), jsData.GetBuffer(), &VarResult);
		jsData.ReleaseBuffer();
	}
	return TRUE;
}

/**
 * @brief Serialize to JSON object
 * @return JSON object as std::string
 */
std::string PeakShapeSpherical::toJSON() const {
  Json::Value root;
  PeakShapeBase::buildCommon(root);
  root["radius"] = Json::Value(m_radius);

  if (m_backgroundInnerRadius && m_backgroundOuterRadius) {
    root["background_outer_radius"] =
        Json::Value(m_backgroundOuterRadius.get());
    root["background_inner_radius"] =
        Json::Value(m_backgroundInnerRadius.get());
  }

  Json::StyledWriter writer;
  return writer.write(root);
}

void enviarNivel(Socket& sockfd, nivel_t& nivel, string* creador = NULL, int jugadores = 0){
    Json::Value mensaje;
    Json::StyledWriter escritor;

    mensaje["tipo"] = (creador == NULL) ? INFO_CREAR : INFO_UNIRSE;
    mensaje["nombre"] = *(nivel.nombre);
    mensaje["creador"] = (creador == NULL) ? "" : *creador;
    mensaje["puntaje"] = htonl((uint32_t) nivel.puntaje);
    mensaje["max jugadores"] = htonl((uint32_t) nivel.cant_jugadores_max);
    mensaje["jugadores"] = htonl((uint32_t) jugadores);
    std::cout<<mensaje;
    std::string envio = escritor.write(mensaje);

    enviarMsjPrefijo(sockfd, envio.c_str(), envio.length());
}

void RtcStream::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {
    std::string cand;
    if (!candidate->ToString(&cand)) {
        LOG(LS_ERROR) << "Failed to serialize candidate";
        return;
    }

    Json::StyledWriter writer;
    Json::Value jmessage;
    jmessage[kCandidateSdpMidName] = candidate->sdp_mid();
    jmessage[kCandidateSdpMlineIndexName] = candidate->sdp_mline_index();
    jmessage[kCandidateSdpName] = cand;
    std::string encodedCand = talk_base::Base64::Encode( writer.write(jmessage));
    SignalIceCandidate(this, encodedCand);
}

string  BatchCall::toString     (bool fast) const
{
    string result;
    if (fast)
    {
        Json::FastWriter writer;
        result = writer.write(this->result);
    }
    else
    {
        Json::StyledWriter writer;
        result = writer.write(this->result);
    }
    return result;
}

QString JsonFormatter::getFormatted()
{
	Json::Value root;   
	Json::Reader reader;
	bool parsingSuccessful = reader.parse( rawValue.toStdString(), root );

	if (!parsingSuccessful)
	{
		return QString("Invalid JSON");
	}

	Json::StyledWriter writer;		

	return QString::fromStdString(writer.write(root));
}

std::string MalwrDTO::toJSON(){
    Json::Value root;
    root["md 5"] = md5;
    root["fileName"] = fileName;
    root["fileType"] = fileType;
    root["antivirusScore"] = antivirusScore;
    root["link"] = link;
    root["date"] = date;

    Json::StyledWriter writer;
    std::string outputConfig = writer.write( root );
//    std::cout << outputConfig << std::endl;

    return outputConfig;
}

static int rewriteValueTree(const std::string& rewritePath,
                            const Json::Value& root,
                            std::string& rewrite) {
  // Json::FastWriter writer;
  // writer.enableYAMLCompatibility();
  Json::StyledWriter writer;
  rewrite = writer.write(root);
  FILE* fout = fopen(rewritePath.c_str(), "wt");
  if (!fout) {
    printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
    return 2;
  }
  fprintf(fout, "%s\n", rewrite.c_str());
  fclose(fout);
  return 0;
}

std::string MetaRequestHandler::constructResponse() {
  const auto &storageManager = StorageManager::getInstance();
  Json::Value result;
  auto &tables = result["tables"];
  for (const auto & tableName: storageManager->getTableNames()) {
    auto &table = tables[tableName];
    auto &columns = table["columns"];
    auto t = storageManager->getTable(tableName);
    table["columnCount"] = t->columnCount();
    for (field_t i = 0; i != t->columnCount(); i++) {
      columns[t->metadataAt(i)->getName()] = t->metadataAt(i)->getType();
    }
  }
  Json::StyledWriter writer;
  return writer.write(result);
}

string JsonTransf::JsonCppToString(Json::Value& jsonValue, const bool bStyled)
{
	string str; 
	if(bStyled)
	{
		Json::StyledWriter writer;
		str = writer.write(jsonValue);
	}
	else
	{
		Json::FastWriter writer;
		str = writer.write(jsonValue);
		str.erase(str.length()-1, 1);
	}
	return str;
}

bool write_user_db(Json::Value *root, const std::string &dbpath)
{
    Json::StyledWriter writer;
    std::ofstream userdb_file;
    std::string userdb_json = writer.write(*root);

    userdb_file.open(dbpath,std::ofstream::trunc);
    if (!userdb_file.is_open())
        return false;

    userdb_file << userdb_json;
    userdb_file.close();

    return true;
    
}

void MapController::saveMap() {

	Json::Value root;

	std::stringstream ss;
	ss << std::hex << this->map->getSeed();
	root["seed"] = ss.str();

	for (int k = 0; k < turnController->playerList.size(); k++) {
		if (turnController->playerList[k] == turnController->getActivePlayer())
		{
			root["turn"] = k;
		}
	}

	Json::Value countryList;

	for (int i = 0; i < this->map->getNumCountries(); i++)
	{
		Json::Value country;
		for (int k = 0; k < turnController->playerList.size(); k++)
		{
			if (std::find(turnController->playerList[k]->countries.begin(), turnController->playerList[k]->countries.end(), this->map->getCountryById(i)) != turnController->playerList[k]->countries.end())
			{
				country["owner"] = k + 1;
				break;
			}
			else
			{
				country["owner"] = 0;
			}
		}

		country["units"] = this->map->getCountryById(i)->getUnits();
		countryList.append(country);
	}

	root["countries"] = countryList;

    Json::StyledWriter writer;

    std::ofstream myfile;
    myfile.open ("savedConfig.json");
    myfile << writer.write(root);

    myfile.close();
}