template <typename _type>
SERIALIZABLE(class test)
    {
        SERIALIZABLE(int var1);
        SERIALIZABLE(_type var2);
        float var3;
    };

void serialize_read_before(void)
void serialize_read_after(void)
void serialize_write_before(void)
void serialize_write_after(void)

1. Code portability — depend only on ANSI C++ facilities.
   Я не буду этого специально добиваться, но использование MS Specific возможностей мне ИМХО не понадобиться. В любом случае MSVC будет для меня приоритетным компилятором и именно на нём всё будет разрабатываться.
   
   
2. Code economy — exploit features of C++ such as RTTI, templates, and multiple inheritance, etc. where appropriate to make code shorter and simpler to use.
   Да.
   
   
3. Independent versioning for each class definition. That is, when a class definition changed, older files can still be imported to the new version of the class.
   Тут мне не ясно, что значит changes. Если речь о том, что был класс (для удобства я обозначаю класс X_v1 и X_v2, но на самом деле у класса должно быть одно и тоже имя (tagname))
   

   SERIALIZABLE(class X_v1)
    {
     SERIALIZABLE(int x);
     SERIALIZABLE(int y);
    }

   
   а стал
   

   SERIALIZABLE(class X_v2)
    {
     SERIALIZABLE(int x);
     SERIALIZABLE(float z);
     SERIALIZABLE(int y);
    }

   
   и надо читать в X_v2 запись X_v1 то это будет реализовано. При этом надо заметить, что значение z будет не определено, но его можно установить реализовав метод serialize_read_before в котором z будет присваиваться некоторое осмысленное значение. Можно присваивать z это осмысленное значение и в конструкторе, если экземпляр класса не используется перед сериализацией
   Тут есть и другой момент. В данном случае
   

   SERIALIZABLE(class X_v1)
    {
     SERIALIZABLE(int x);
    }

   
   а стал
   

   SERIALIZABLE(class X_v2)
    {
     SERIALIZABLE(int y);
    }

   
   Значение y будет не определено, а значение x потеряется
   
   
4. Deep pointer save and restore. That is, save and restore of pointers saves and restores the data pointed to.
   В принципе да, хотя кольцевой список как целевой контейнер и вообще кольцевые ссылки меня не очень вдохновляют. не думаю, что смогу это эффективно реализовать на первых стадиях.
   
   
5. Proper restoration of pointers to shared data.
   Если речь о том, что указатели ptr1 и ptr2 одного типа указывали на один и тот же объект, то после десериализации они долны продолжать указыват на один и тот же объект, то реализация этого условия тесно связана с реализацией предыдущего.
   
   
6. Serialization of STL containers and other commonly used templates.
   Да.
   
   
7. Data Portability — Streams of bytes created on one platform should be readable on any other.
   Интересное требование, не думаю, что это будет реализовано.
   
   
8. Orthogonal specification of class serialization and archive format. That is, any file format should be able to store serialization of any arbitrary set of C++ data structures without having to alter the serialization of any class.
   
   Скорее да, чем нет, хотя Windows INI files меня мало привлекают Скорее всего будет XML storage и binary storage. Есть идея сделать архив на основе OLE Structured Storage и RIFF
   
   
9. Non-intrusive. Permit serialization to be applied to unaltered classes. That is, don't require that classes to be serialized be derived from a specific base class or implement specified member functions. This is necessary to easily permit serialization to be applied to classes from class libraries that we cannot or don't want to have to alter.
   Да, никаких специальных базовых классов или необходимых к реализации методов не будет. Только уже указанная мною маркировка, либо ручная реализация пары функций (маркировка проще, ручная реализация потребуется для STL — не патчить же STL)
   
   
10. The archive interface must be simple enough to easily permit creation of a new type of archive.
    
    Архив должен уметь сериализовывать некоторый набор базовых типов (char, int, long, float, double, tagVARIANT)
    Архив должен поддерживать древовидную структуру.
    Значение получается по имени переменной.
    
    
11. The archive interface must be rich enough to permit the creation of an archive that presents serialized data as XML in a useful manner.
    Да.

SERIALIZABLE(union test)
 {
  char x;
  short y;
  SERIALIZABLE(int largest_var)
 }

1. Independent versioning for each class definition. That is, when a class definition changed, older files can still be imported to the new version of the class.
   
   Выбор какие поля читать, а какие нет основыватся на наличии этих полей (для идентификации используется пара декорированное имя типа + имя поля) и выполняется автоматически. Никаких if (version > 3) read(advanced_field) не будет.

if (storage.exists(0x12345678)) read(012345678, &obj.field);

template <typename _type>
SERIALIZABLE(class test)
    {
        void prop_set(int value);
        int prop_get();
        SERIALIZE_PROPERTY(int, prop_set, prop_get);
        SERIALIZE_VALUE(float var3);
    };

SERIALIZABLE(class myclass)
 {
  public:
   SERIALIZE_VALUE(std::string name);
 }

<root>
 <myclass>
  <name>value of the string object</name>
 </myclass>
</root>

<root>
 <myclass>
  <std__string:name>value of the string object</std__string:name>
 </myclass>
</root>

<root>
 <myclass>
  <name __type="std::string">value of the string object</name>
 </myclass>
</root>

<root>
 <myclass>
  <name>value of the string object</name>
 </myclass>
</root>

<root>
 <myclass name="value of the string object">
 </myclass>
</root>

SERIALIZABLE(class myclass)
 {
  public:
   SERIALIZE_VALUE(std::string name);
 }

SERIALIZABLE(class myclass)
 {
  public:
   SERIALIZE_ATTRIBUTE(std::string name);
 }

A>>Не буду её читать наверное Ведь старый тип не факт что как-то приводиться к новому. А что ты предлагаешь?

SERIALIZABLE(class A)
 {
  SERIALIZE_VALUE(int x);
  SERIALIZE_VALUE(int y);
 }

SERIALIZABLE(class A)
 {
  SERIALIZE_VALUE(int y);
  SERIALIZE_VALUE(int x);
 }

Y>черт его знает... ты хочешь, чтобы я тебе на гору выдал ответы на все вопросы бытия

template <typename _type>
SERIALIZABLE(class test)
    {
        SERIALIZABLE(int var1);
        SERIALIZABLE(_type var2);
        float var3;
    };

template <typename _type>
class test
    {
        DECLARE_SERIALIZABLE;
        int var1;
        _type var2;
        float var3;
    };

template <typename _type>
class test
    {
        DECLARE_SERIALIZABLE;
        int var1;
        _type var2;
        unserializable<float> var3;
    };

A>template <typename _type>
A>class test
A>    {
A>        DECLARE_SERIALIZABLE;
A>        int var1;
A>        _type var2;
A>        unserializable<float> var3;
A>    };
A>

template <typename _type>
class test
    {
        serializable<int> var1;
        serializable<_type> var2;
        float var3;
    };

template <typename _type>
class test
    {
        serializable<int, 1> var1;
        serializable<_type, 2> var2;
        serializable<std::string, 3> str;
        float var3;
    };

A>>>Не буду её читать наверное Ведь старый тип не факт что как-то приводиться к новому. А что ты предлагаешь?

    void serialize(Archive & ar, const unsigned int version)
    {
        // only save/load driver_name for newer archives
        if(version > 0)
            ar & driver_name;
        ar & stops;
    }

A>Я спрашиваю как лично тебе удобнее. Соберу мнения и будет мне счастие На все вкусы всё равно не сделать, но есть задумки. Хотелось бы не гнать пургу в одиночку, а посовещаться.

MS>template <typename _type>
MS>class test
MS>    {
MS>        serializable<int> var1;
MS>        serializable<_type> var2;
MS>        float var3;
MS>    };
MS>

MS>template <typename _type>
MS>class test
MS>    {
MS>        serializable<int, 1> var1;
MS>        serializable<_type, 2> var2;
MS>        serializable<std::string, 3> str;
MS>        float var3;
MS>    };
MS>

0: test<float>, fields
    {
        0: int = var1
        1: float = var2
        2: std::string = str
    };

0:
    {
        0: 45;
        1: 3.67f;
        2: "qwerty"
    }