5

我正在使用带有 C++ 的 MessagePack，我正在尝试反序列化这个 Python 映射的等价物：

{'metadata': {'date': '2014-06-25', 'user_id': 501},
 'values': [3.0, 4.0, 5.0],
 'version': 1}

顶级对象是带有字符串键的映射，但值的类型完全不同。我的代码提前知道对象的结构应该是什么；我应该能够声明一个整数，然后告诉我的反序列化代码，“version键的值是一个整数，所以把那个整数的值放到这个内存地址中。”</p>

问题是我什至不确定如何达到我的 C++ 代码可以将此结构视为映射的地步。我希望做类似的事情

msgpack::unpacker unpacker;
// ...copy the data into unpacker's buffer...

msgpack::unpacked message;
std::map<std::string, anything> output_map;

unpacker.next(&message);
msgpack::object obj = message.get();
obj.convert(&output_map);

int version_number = output_map.at("version");

是否有任何可能的类型 ( anything) 可以在这里工作？MessagePack 文档只有一些简单的示例，这篇博文更好，但没有涵盖这个用例。

4

2 回答 2

1

你可以使用 boost::variant 来做到这一点。要实现递归结构，可以使用 oost::make_recursive_variant 如下：

typedef boost::make_recursive_variant<
    std::string,
    std::map<boost::recursive_variant_, boost::recursive_variant_>,
    std::vector<boost::recursive_variant_>,
    int,
    double
    >::type variant_t;

这是一个文档： http: //www.boost.org/doc/libs/1_55_0/doc/html/variant/tutorial.html#variant.tutorial.recursive.recursive-variant

您还需要编写一个转换器，将 msgpack::object 转换为 variant_t，反之亦然，如下所示：

// Custom converter for variant_t
namespace msgpack {

// Convert from msgpacl::object to variant_t.
inline variant_t& operator>>(object const& o, variant_t& v) {
    switch(o.type) {
    case type::MAP:
        v = std::map<variant_t, variant_t>();
        o.convert(boost::get<std::map<variant_t, variant_t> >(&v));
        break;
    case type::ARRAY:
        v = std::vector<variant_t>();
        o.convert(boost::get<std::vector<variant_t> >(&v));
        break;
    case type::POSITIVE_INTEGER:
        v = int();
        o.convert(boost::get<int>(&v));
        break;
    case type::DOUBLE:
        v = double();
        o.convert(boost::get<double>(&v));
        break;
    case type::RAW:
        v = std::string();
        o.convert(boost::get<std::string>(&v));
        break;
    default:
        break;
    }
    return v;
}


// Convert from variant_t to msgpacl::object.
template <typename Stream>
struct packer_imp:boost::static_visitor<void> {
    template <typename T>
    void operator()(T const& value) const {
        o_.pack(value);
    }
    packer_imp(packer<Stream>& o):o_(o) {}
    packer<Stream>& o_;
};

template <typename Stream>
inline packer<Stream>& operator<< (packer<Stream>& o, const variant_t& v)
{
    boost::apply_visitor(packer_imp<Stream>(o), v);
    return o;
}

} // namespace msgpack

您可以从 gist 获取完整的示例代码： https ://gist.github.com/redboltz/672c5af16b2907488977 我在示例中使用了 C++11 功能，因此您需要添加 -std=c++11 选项.

于 2014-06-28T16:28:58.937 回答
0

我最终对此进行了抨击并编写了自己的基于文本的序列化格式。它通常不像 MessagePack 那样有用，但它允许我解决这些静态类型的问题。

于 2014-08-07T20:58:39.407 回答