扩展boost序列化

Question

我正在尝试为移动设备的网络视频游戏设置多用途序列化.因为它是联网的,所以在初始连接期间我需要为游戏状态序列化所有数据,但是,一旦游戏正在进行中,我只需要序列化某些更改.作为boost序列化库一部分的save和load方法仅具有版本号作为参数.我希望能够做的是有更多的参数,这样我可以改变什么得到保存和加载基于不仅仅是一个版本号的详细条件.

Boost序列化文档在这里,供参考.

这是普通的boost序列化save方法目前的样子:

template<class Archive>
void save(Archive& ar, const unsigned int version) const
{
    // Serialize stuff here
}

这就是我想要完成的事情:

template<class Archive>
void save(Archive& ar, const unsigned int version, const unsigned int state_flags) const
{
    if (state_flags & INITIAL_SERIALIZATION)
    {
        // Serialize only data needed for an initial serialization
    }

    // Other serialization
}

我怀疑我可以让boost库调用我想要的序列化方法,因为它重载了运算符,在上面的第一个例子中调用了一个具有特定签名的运算符.我想象在第一个例子中显示save的调用中调用我自己的版本save,并且可能state_flags从一个单独的位置抓取.有没有人对如何干净利落或任何好的替代方案有任何想法？

编辑:我遇到了另一个问题.我需要序列化不一定是类成员的对象,但是文档没有提到对此的任何支持.

这是一个简单的例子:

class Foo
{
private:
    SomeClass m_object;

    template<class Archive>
    void save(Archive& ar, const unsigned int version) const
    {
        Bar* pBar = m_object->getComponent<Bar>();
        ar & pBar;   // <--- But pBar isn't a member of Bar, it's part of SomeClass.
    }
};

我只是序列化SomeClass并让它涓涓细流Bar,但在这种情况下,它是一个类,它是第三方库/引擎的一部分,而不是我可以修改的东西.Will Boost序列化是否允许我以这种方式序列化和反序列化？

Answer 1

编辑：下面添加了新答案以解决实际问题。

您的问题意味着您重复反序列化到同一个对象。无论干净与否，这都是间接的。例如，如果您有一个国际象棋棋盘，您可能希望同步棋子的初始位置（从上次保存的游戏继续）。为了在玩游戏时传达动作，最好将各个动作作为单独的对象发送（然后在收到后应用于棋盘对象），而不是传输整个棋盘对象，因为后者只会传输已更改的内容如果它已经“初始化”。这样您就可以首先验证输入并忽略无效的移动。不管怎样，我只是想提一下，让我们继续吧。

如果您有一个可以多次同步的对象，并且成员数据只需要传输一次，请让该对象决定它是否“初始化”（以及因此，如果它需要传输所有内容或只是一个子集）通过使用标志（未序列化）。

然后，您可以检查对象的序列化代码中的标志，就像您发布的代码一样（不同之处在于该标志不是序列化方法的参数，而是您要反/序列化的对象的成员变量）。如果设置了标志，则反/序列化所有内容并重置标志。客户端和服务器必须具有相同的标志状态，否则序列化会中断。

或者，您可以首先序列化标志，以告诉接收器必须如何执行反序列化（例如，每个成员数据组对应一位）。

请记住，反序列化必须与序列化相匹配；您必须按照序列化的顺序提取相同的对象。

但是，您可以序列化多态类，因为它们是通过类层次结构中与反序列化相同的级别进行序列化的（如有疑问，请在发送时强制转换为基指针，并通过基指针进行反序列化）。

关于你的第二个问题，你正在寻找的是非侵入式序列化。非侵入式序列化调用独立函数并将要序列化的对象作为参数传递（这就是 std::vector 和 boost::shared_ptr 的序列化方式）。您可以使用BOOST_SERIALIZATION_SPLIT_FREE将独立serialize()函数拆分为save()和load()。对于侵入式序列化，它是BOOST_SERIALIZATION_SPLIT_MEMBER.

要编写通用的反/序列化函数（例如通过网络传输对象），您可以使用模板：

template<typename T>
void transmit( const T& data ) {
    // ...
    archive << data
    socket << archive_stream;
}

此方法的限制是接收者必须知道发送的对象类型。如果您想发送随机对象，请将它们设为多态：

IData* data = 0;
archive >> data;
switch( data->type() ) {
case TYPE_INIT:
    return dispatch( static_cast<Board*>(data) );
case TYPE_MOVE:
    return dispatch( static_cast<Move*>(data) );
case TYPE_CHAT:
    return dispatch( static_cast<ChatMsg*>(data) );
}

更新：如果您需要根据正在序列化的类型未知的状态来控制（自定义）序列化方法/函数的行为方式，您可以实现自己的保存该状态的存档类。然后，序列化函数可以查询状态并采取相应的操作。

该状态（或适当的替换）也必须被序列化，以指示数据必须如何反序列化。例如，序列化函数的这种“不同行为”可能是某种压缩，而状态就是所使用的压缩类型。

这是自定义输出存档的最小示例。欲了解更多信息，您可以阅读Derivation from an Existing Archive并挖掘提升源。

给定一个您无法修改的类：

struct Foo {
    Foo() : i(42), s("foo") {}
    int i;
    std::string s;
};

您希望序列化i和/或s基于类未知的条件。您可以创建一个包装器来序列化它并添加状态，但如果对象位于向量（或其他类）内部，则这将不起作用。

让存档了解状态可能会更容易：

#include <boost/archive/text_oarchive.hpp>

// using struct to omit a bunch of friend declarations    
struct oarchive : boost::archive::text_oarchive_impl<oarchive>
{
    oarchive(std::ostream& os, unsigned flags=0)
      : boost::archive::text_oarchive_impl<oarchive>(os,flags),mask(0){}

    // forward to base class
    template<class T> void save( T& t ) {
        boost::archive::text_oarchive_impl<oarchive>::save(t);
    }

    // this is the 'state' that can be set on the archive
    // and queried by the serialization functions
    unsigned get_mask() const { return mask; }
    void set_mask(unsigned m) { mask = m; }
    void clear_mask() { mask = 0; }
private:
    unsigned mask;
};

// explicit instantiation of class templates involved
namespace boost { namespace archive {
   template class basic_text_oarchive<oarchive>;
   template class text_oarchive_impl<oarchive>;
   template class detail::archive_serializer_map<oarchive>;
} }

// template implementations (should go to the .cpp)
#include <boost/archive/impl/basic_text_oarchive.ipp>
#include <boost/archive/impl/text_oarchive_impl.ipp>
#include <boost/archive/impl/archive_serializer_map.ipp>

现在要设置和查询的状态：

enum state { FULL=0x10, PARTIAL=0x20 };

以及设置状态的方法（这只是一个非常基本的示例）：

oarchive& operator<<(oarchive& ar, state mask) {
    ar.set_mask(ar.get_mask()|mask);
    return ar;
}

最后是（非侵入式）序列化函数：

namespace boost { namespace serialization {

template<class Archive>
void save(Archive & ar, const Foo& foo, const unsigned int version)
{
    int mask = ar.get_mask(); // get state from the archive
    ar << mask; // serialize the state! when deserializing,
    // read the state first and extract the data accordingly

    if( mask & FULL )
        ar << foo.s; // only serialize s if FULL is set
    ar << foo.i;     // otherwise serialize i only
    ar.clear_mask(); // reset the state
}

} } // boost::serialization

BOOST_SERIALIZATION_SPLIT_FREE(Foo)

可以按如下方式使用：

int main() {
    std::stringstream strm;
    oarchive ar(strm);

    Foo f;
    ar << PARTIAL << f << FULL << f;

    std::cout << strm.str();
}

这个例子的目的只是为了说明原理。对于生产代码来说它太基础了。