为什么提高产树write_json保存的一切，因为串?是否有可能改变吗？

StackOverflow https://stackoverflow.com/questions/2855741

  •  27-09-2019
  •  | 
  •  

题

我试图列化使用提高产树write_json，这样可以节省一切串，它不是这些数据是错误的，但我需要投他们明确每次我要使用他们在其他地方。(像在蟒蛇或其他C++json(非的提升)图书馆)

这里是一些样品代码什么我得到根据语言环境：

boost::property_tree::ptree root, arr, elem1, elem2;
elem1.put<int>("key0", 0);
elem1.put<bool>("key1", true);
elem2.put<float>("key2", 2.2f);
elem2.put<double>("key3", 3.3);
arr.push_back( std::make_pair("", elem1) );
arr.push_back( std::make_pair("", elem2) );
root.put_child("path1.path2", arr);

std::stringstream ss;
write_json(ss, root);
std::string my_string_to_send_somewhare_else = ss.str();

和 my_string_to_send_somewhere_else 是sth。是这样的：

{
    "path1" :
    {
       "path2" :
       [
            {
                 "key0" : "0",
                 "key1" : "true"
            },
            {
                 "key2" : "2.2",
                 "key3" : "3.3"
            }
       ]
    }
}

反正是有保存他们的价值观，如："key1" : true 或 "key2" : 2.2?

有帮助吗？

解决方案

最简单和最干净的解决方案我可以拿出物产生id与占位并在结束时串更换的实际价值的抛弃额外的报价。

static string buildGetOrdersCommand() {
    ptree root;
    ptree element;
    element.put<string>("pendingOnly", ":pendingOnly");
    element.put<string>("someIntValue", ":someIntValue");

    root.put("command", "getOrders");
    root.put_child("arguments", element);

    std::ostringstream buf;
    write_json(buf, root, false);
    buf << std::endl;

    string json = buf.str();
    replace(json, ":pendingOnly", "true");
    replace(json, ":someIntValue", std::to_string(15));

    return json;
}

static void replace(string& json, const string& placeholder, const string& value) {
    boost::replace_all<string>(json, "\"" + placeholder + "\"", value);
}

结果是

{的"命令":"getOrders"，"论据":{"pendingOnly":true,"someIntValue":15}}

其他提示

Ok，我已经解决了它就像这样，(当然这不会有套房的每个人，因为它是一个黑客，需要进一步的工作)。

我写了我自己 write_json 功能(简单复制的文件， json_parser.hpp 和 json_parser_write.hpp 我的项目)和修改以下线 json_parser_write.hpp:

  1. 评线37-逃跑的报'"'
  2. 改变行的76因此，它不加价了：stream << Ch('"') << data << Ch('"'); ==> stream << data;

然后值将被保存正确除串，因此我写定翻译为：

template <typename T>
struct my_id_translator
{
    typedef T internal_type;
    typedef T external_type;

    boost::optional<T> get_value(const T &v) { return  v.substr(1, v.size() - 2) ; }
    boost::optional<T> put_value(const T &v) { return '"' + v +'"'; }
};

和简单的保存字符串中使用:

elem2.put<std::string>("key2", "asdf", my_id_translator<std::string>());

完整程序：

#include <iostream>
#include <string>
#include <sstream>

#include <boost/property_tree/ptree.hpp>

#include "property_tree/json_parser.hpp" // copied the headers

template <typename T>

struct my_id_translator
{
    typedef T internal_type;
    typedef T external_type;

    boost::optional<T> get_value(const T &v) { return  v.substr(1, v.size() - 2) ; }
    boost::optional<T> put_value(const T &v) { return '"' + v +'"'; }
};

int main(int, char *[])
{
    using namespace std;
    using boost::property_tree::ptree;
    using boost::property_tree::basic_ptree;
    try
    {
        ptree root, arr,elem2;
        basic_ptree<std::string, std::string> elem1;
        elem1.put<int>("int", 10 );
        elem1.put<bool>("bool", true);
        elem2.put<double>("double", 2.2);
        elem2.put<std::string>("string", "some string", my_id_translator<std::string>());

        arr.push_back( std::make_pair("", elem1) );
        arr.push_back( std::make_pair("", elem2) );
        root.put_child("path1.path2", arr);

        std::stringstream ss;
        write_json(ss, root);
        std::string my_string_to_send_somewhere_else = ss.str();

        cout << my_string_to_send_somewhere_else << endl;

    }
    catch (std::exception & e)
    {
        cout << e.what();
    }
    return 0;
}

结果:)

{
    "path1":
    {
        "path2":
        [
            {
                "int": 10,
                "bool": true
            },
            {
                "double": 2.2,
                "string": "some string"
            }
        ]
    }
}

提高确认其执行情况有没有100%的合规性叉的标准。检查下列链接查看他们的解释：使ptree变保留JSON类型是一个未来的计划，但远了。!

正如我们typedef basic_ptree<std::string, std::string=""> ptree;在提高图书馆，提高总是将序列的每个数值作为串和分析所有价值观的一串等同的。

从输出JSON清楚的是，该程序将一切串使用某种形式的。toString()方法-也就是说，它不知道有类型的每一成员和所包围的一切都在"".

看看 创造JSON阵列，在提高使用的财产树木 欲了解更多有关这个问题。

我结束了增加的另一个函数向我的工具来解决这个:

#include <string>
#include <regex>
#include <boost/property_tree/json_parser.hpp>

namespace bpt = boost::property_tree;
typedef bpt::ptree JSON;
namespace boost { namespace property_tree {
    inline void write_jsonEx(const std::string & path, const JSON & ptree)
    {
        std::ostringstream oss;
        bpt::write_json(oss, ptree);
        std::regex reg("\\\"([0-9]+\\.{0,1}[0-9]*)\\\"");
        std::string result = std::regex_replace(oss.str(), reg, "$1");

        std::ofstream file;
        file.open(path);
        file << result;
        file.close();
    }
} }

希望这有所帮助。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top