在c++中使用MessagePack反序列化异构映射

Deserializing a heterogeneous map with MessagePack in C++

本文关键字：反序列化 异构 映射 MessagePack c++      更新时间：2023-10-16

我在c++中使用MessagePack，我试图反序列化这个Python映射的等量:

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

顶层对象是一个带有字符串键的map，但是值的类型完全不同。我的代码提前知道对象的结构应该是什么;我应该能够声明一个整数，然后告诉我的反序列化代码，"version键的值是一个整数，所以把这个整数的值放入这个内存地址。"

问题是，我甚至不确定如何达到我的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文档只有一些简单的例子，这篇博客文章更好，但没有涵盖这个用例。

您可以使用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选项。

我最终放弃了这一点，编写了自己的基于文本的序列化格式。它通常不像MessagePack那样有用，但它允许我掩盖这些静态类型问题。

相关文章：