撤销和重做(Undo和Redo)的C++完美实现(9)

#if 0

    在这一章里面将会讨论到该撤销和重做库的序列化问题。序列化几乎是每一个应用程
序中都会考虑到的问题，在本系列文档的开始就已经提到了该撤销和重做库天生具备了序
列化能力，那么在本文中将会详细的讨论序列化的问题。并且尽可能的给出非常具有弹性
的序列化框架。

    为了保证该序列化框架的弹性，我将该序列化框架分为三大部分：

    (1)档案类，专门负责档案格式的

    (2)序列化类，专门负责序列化框架，将一些固有的流程采用自动化方法实现

    为了保证该序列化框架的易用性，必须声明一声：该序列化框架是专门针对该撤销和
重做库的。所以对于该撤销和重做库进行了大量的自动化实现，包括简单类型的序列化的
自动化实现，复合类型的序列化的自动化实现和控制类的序列化的自动化实现。是否需要
序列化功能，仅仅添加一个类还是删除一个类的问题。所以使用起来非常的方便。

#endif
#ifdef ARCHIVE_H//档案类的实现
struct text_tag;//文本档案标签
struct binary_tag;//二进制档案标签
//支持文本格式的档案
template <class StreamType,class TAG>struct archive;
template <class StreamType>struct archive<StreamType,text_tag>
{
 
        archive(StreamType&S):_S(S){}
        template <class T> archive&write(const T&O)
        {
 
                _S << " " << O << " ";
                return *this;
        }
        template <class T> archive&read(T&O)
        {
 
                _S >> O;
                return *this;
        }
        //流不允许出现const类型，也就是说所有的流都是可以改动的
        operator StreamType&(){
 return _S;}
private:
        StreamType&_S;
};
//支持二进制格式的档案
template <class StreamType>struct archive<StreamType,binary_tag>
{
 
        archive(StreamType&S):_S(S){}
        template <class T> archive&write(const T&o)
        {
 
                _S.write(reinterpret_cast<const char*>(&o),sizeof(T));
                return *this;
        }
        template <class T> archive&read(T&o)
        {
 
                _S.read(reinterpret_cast<char*>(&o),sizeof(T));
                return *this;
        }
        //流不允许出现const类型，也就是说所有的流都是可以改动的
        operator StreamType&(){
 return _S;}
private:
        StreamType&_S;
};
//任何其它的格式都必须有上面的write函数和read函数，下面给出一个可扩展的档案格式
//类代码模板
//template <class StreamType>struct archive<StreamType,other_tag>
//{
  
//      archive(StreamType&S):_S(S){}
//      template <class T> archive&write(const T&o)
//      {
  
//              //在这里实现你自己的序列化写出功能
//              return *this;
//      }
//      template <class T> archive&read(T&o)
//      {
  
//              //在这里实现你自己的序列化读取功能
//              return *this;
//      }
//      //流不允许出现const类型，也就是说所有的流都是可以改动的
//      operator StreamType&(){return _S;}
//private:
//      StreamType&_S;
//};
#endif//ARCHIVE_H
#ifdef SERIALIZE_H//序列化类的实现
#include "language.h"//LOOP
#include "traits.h"//traits
#include "tuple.h"//tuple
#include "control.h"
namespace xcl=pandaxcl;
//有时候并不需要将控制类中的所有类型都序列化出来，这里给出一个类型串来选择在控
//制类中的需要序列化的类型
template <class T>struct serialize;
//针对于tuple类型的特化，tuple类型可以作为简单类型使用，也就是针对于简单类型的
//特化
template <class ConsType>struct serialize<xcl::tuple<ConsType> >
{
 
        typedef ConsType cons_type;
        typedef xcl::tuple<ConsType> target_type;
        //下面的两个函数是任何类型都必须遵守的规范，必须提供这两个函数
        template <class ArchiveType,class ControlType>
        static ArchiveType&write(ArchiveType&AR,const ControlType&C,const target_type&O)
        {
 
                const int Length = xcl::length<cons_type>::value;
                WRITE_ENVIRONMENT<ArchiveType,ControlType> e(AR,C,O);
                xcl::LOOP<WRITE,0,Length>::execute(e);
        }
        template <class ArchiveType,class ControlType>
        static ArchiveType&read(ArchiveType&AR,ControlType&C,target_type&O)
        {
 
                const int Length = xcl::length<cons_type>::value;
                READ_ENVIRONMENT<ArchiveType,ControlType> e(AR,C,O);
                xcl::LOOP<READ,0,Length>::execute(e);
        }
private:
        template <class ArchiveType,class ControlType>
        struct WRITE_ENVIRONMENT
        {
 
                WRITE_ENVIRONMENT(ArchiveType&AR,const ControlType&C,const target_type&O)
                        :_AR(AR),_C(C),_O(O){}
                ArchiveType       &_AR;
                const ControlType &_C;//常量