Question

我正在使用MessagePack和C ++，我正在尝试反序列化这个Python地图的等价物：

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

顶级对象是带有字符串键的映射，但值的类型完全不同。我的代码提前知道对象的结构应该是什么;我应该能够声明一个整数，然后告诉我的反序列化代码，“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文档只有一些简单的例子，this blog post更好，但不包括这个用例。

Answer 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选项。

Answer 2

我最终在这上面写了my own text-based serialization format。它通常不像MessagePack那样有用，但它允许我记录这些静态输入问题。

使用C ++中的MessagePack反序列化异构映射

2 个答案: