处理从 boost 序列化中删除的变量

Question

我查看了网络上关于通过增加版本号并在该变量的序列化周围添加一个 "if" 来向序列化函数添加成员变量的示例。

但是删除成员变量怎么办？我是否应该将它从序列化函数中删除，boost 会处理它？

如果我在序列化函数中删除了一些 "serialize" 的类，情况可能会变得更糟，我是否需要只为该序列化代码保留它们，还是有其他方法？

Answer 1

后台/存档格式兼容性

Boost Serialization 在很多情况下都非常轻量级。

具体来说，如果您不使用对象 tracking/dynamic 多态性，那么在使您的序列化流兼容时会有惊人的回旋余地。

在通过（智能）指针（指向基）进行序列化时，跟踪和多态性都成为一个因素。

标准库以及现代 C++ 中的大多数内容都支持值语义（例如所有标准容器），并且直接暗示在这里发挥良好。

As a specific example, I've had lots of success serializing
std::map<std::string, boost::uuids::uuid>
into a binary archive, and de-serializing this archive as
boost::unordered_map<std::string, boost::uuids::uuid>
// or
boost::flat_map<std::string, boost::uuids::uuid>
// or
std::vector<std::pair<std::string, boost::uuids::uuid> >

None这些类型（需要）存储类型信息，所以二进制流是兼容可交换的。

也许如果你想依赖这种"incidental"兼容性，你可能想写广泛测试.

I have a feeling you should be able to devise a trivial archive implementation that, instead of serializing actual data, creates a "layout map" or "compatibility signature" of the data-structures involved.

This could go a long way to gaining the confidence to verify archive-compatibility between distinct types

案例研究 1：更改布局

这与原始问题非常吻合："How do I de-serialize old versions once a field has been removed"。

这里，关键是：serialize只是一个函数。你可以做任何你需要的。拿一个经历了两个版本的简单演示 class：

struct MyType {
    MyType();
    MyType(std::string const& v);

  private:
    friend class boost::serialization::access;
    template <typename Ar> void serialize(Ar&, unsigned);

#if DEMO_VERSION == 0

    bool hasValue;
    std::string value;

#elif DEMO_VERSION == 1

    boost::optional<std::string> value;

#endif
};

显然，这些版本会有不同的实现。

诀窍是反序列化为临时变量，然后根据您的业务规则将旧语义映射到新语义上：

#if DEMO_VERSION == 0
MyType::MyType()                     : hasValue(false)          {}
MyType::MyType(std::string const &v) : hasValue(true), value(v) {}

template <typename Ar> void MyType::serialize(Ar& ar, unsigned /*file_version*/) {
    ar & hasValue & value; // life was simple in v0
}

#elif DEMO_VERSION == 1
MyType::MyType()                     : value(boost::none)       {}
MyType::MyType(std::string const &v) : value(v)                 {}

template <typename Ar> void MyType::serialize(Ar& ar, unsigned file_version) {
    switch (file_version) {
        case 0: {
            assert(Ar::is_loading::value); // should not be writing old formats
            //
            bool        old_hasValue;      // these fields no longer exist
            std::string oldValue;

            ar & old_hasValue & oldValue;

            // translate to new object semantics/layout
            value.reset();
            if (old_hasValue) value.reset(oldValue);

            break;
        }
        default: // v1+
            ar & value;
    }
}
#endif

您可以在 Coliru 上看到这个过程，其中程序 v0 将对象写入 v0.dat，程序 v1 成功读取（并以新格式序列化）：

Live On Coliru

BOOST_CLASS_VERSION(MyType, DEMO_VERSION)
#include <fstream>

namespace demo {
    template <typename T> void serialize(std::ostream& os, T const& obj) {
        {
            boost::archive::text_oarchive oa(os);
            oa << obj;
        }
        os.flush();
    }

    template <typename T> void save(std::string const& fname, T const& payload) {
        std::ofstream ofs(fname, std::ios::binary);
        serialize(ofs, payload);
    }

    MyType load(std::string const& fname) {
        std::ifstream ifs(fname, std::ios::binary);

        MyType obj;

        boost::archive::text_iarchive ia(ifs);
        ia >> obj;

        return obj;
    }
}

int main(int, char** cmd) {
    std::cout << "Running " << *cmd << " with DEMO_VERSION=" << DEMO_VERSION << "\n";
    using namespace demo;

#if DEMO_VERSION == 0

    MyType payload("Forty two");
    save     ("v0.dat", payload);  // uses v0 format
    serialize(std::cout, payload); // uses v0 format

#elif DEMO_VERSION == 1

    auto loaded = load("v0.dat");  // still reads the v0 format
    serialize(std::cout, loaded);  // uses v1 format now

#endif
}

打印：

for v in 0 1
do
    g++ -std=c++11 -Os -Wall -DDEMO_VERSION=$v main.cpp -o v$v -lboost_system -lboost_serialization
    ./v$v
done
Running ./v0 with DEMO_VERSION=0
22 serialization::archive 11 0 0 1 9 Forty two
Running ./v1 with DEMO_VERSION=1
22 serialization::archive 11 0 1 0 0 1 0 9 Forty two

案例研究 2：changed/removed 类型

正如您所说，最简单的方法可能是保留旧类型以进行间接反序列化。

参考上面"Background / Archive format compatibility"部分，当然还有另一种选择，只要你知道自己在做什么。

让我们假设上面的示例 ("Case Study 1") 略有不同，并使用 PoorMansOptional<std::string> 替换为 boost::optional<std::string>。您可以找出要反序列化的等效字段。

Take note of the extra item version fields that might be interspersed. Such fields are conveniently absent between items in the container examples mentioned above.

处理从 boost 序列化中删除的变量

Handle removed variable from boost serialize

c++

serialization

boost

后台/存档格式兼容性

案例研究 1：更改布局

案例研究 2：changed/removed 类型