Problem with serialization

[okinrus]

Can someone take a look at this code and figure out why
Serializable_ba se::add_seriali zer throws std::bad_alloc. The problem
seems to be the compiler because msvc++ 7.1 says
c:\LibSerial\Li bSerial.cpp(83) : warning C4584: 'serial::E' :
base-class 'serial::A' is already a base-class of 'serial::C'
c:\LibSerial\Li bSerial.cpp(10) : see declaration of
'serial::A'
c:\LibSerial\Li bSerial.cpp(48) : see declaration of
'serial::C'
#include <vector>
#include <iostream>

//#include "Archive.h"
//
// Archive is an abstract class that defines write(int), write(float)
etc.
// But for our purposes it can be just defined to be
//
namespace serial {

class Archive { };

template<class T>
inline Archive& operator&=(Arch ive& ar, T& x)
{
return ar;
}

}

namespace serial {

class Serializable_ba se;
class Serial_holder;

// Serialize_base will store a vector of
// Serialize_actio n_base objects which
// will then be called back in predefined order
// at serialization
class Serialize_actio n_base
{
public:
virtual void serialize(Archi ve& ar) = 0;
};

// This should call the serialize method of a class T
template<typena me T>
class Serialize_actio n : public Serialize_actio n_base
{
T* sc;
public:
Serialize_actio n() : sc(0)
{ }

void set_obj(T* serial)
{
sc = serial;
}

void serialize(Archi ve& ar)
{
if (sc != 0)
{
sc->T::serialize(a r);
}
}
};

// Serializable virtually inherits from this class to retrieve
// a unique id
class Serializable_ba se
{
friend class Serial_holder;
public:
Serializable_ba se()
{
std::cout << "Serializable_b ase()" << std::endl;
}

virtual ~Serializable_b ase()
{
std::cout << "Serializable_b ase destroyed" << std::endl;
}
protected:
// this is where std::bad_alloc is thrown
void add_serializer( Serialize_actio n_base* serializer)
{
serializers.pus h_back(serializ er);
}
private:
typedef std::vector<Ser ialize_action_b ase*> serializer_acti ons;
serializer_acti ons serializers;
void serialize_all(A rchive& ar)
{
std::cout << "num serializers = " << serializers.siz e() <<
std::endl;
for (size_t i = 0; i < serializers.siz e(); ++i)
serializers[i]->serialize(ar );
}
};
// T is the class that inherits from this class
template<typena me T>
class Serializable : public virtual Serializable_ba se
{
typedef T Base;

friend class Serialize_actio n;

// This serialize method function should be invoked within the
// Serialize_actio n object. It should just call the class
// who derives from this class serialize method, which
// means that any class that we should be able to make a
// given class Serializable by writing
//
// class C : public Serializable<C>
// {
// void serialize(Archi ve& ar) { }
// };
void serialize(Archi ve& ar)
{
Base* base = dynamic_cast<Ba se*>(this);
if (base)
base->serialize(ar );
}
public:
Serializable()
: Serializable_ba se()
{
std::cout << "Serializable() " << std::endl;
sa.set_obj(this );
add_serializer( &sa);
}
private:
Serialize_actio n<Serializable< T> > sa;
};

class Serial_holder
{
public:
Serial_holder(S erializable_bas e* r)
: root(r)
{ }
void serialize(Archi ve& ar)
{
root->serialize_all( ar);
}
private:
Serializable_ba se* root;
};

}

#endif

//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////

// Do some tests of the serialize classes
#include "LibSerial. h"
#include <iostream>
using namespace serial;
class A : public Serializable<A>
{
int a;
int b;
int c;
public:
A() : a(1), b(2), c(3) { }

~A()
{
std::cout << "A destroyed" << std::endl;
}

void serialize(Archi ve& ar)
{
std::cout << "Serializin g A" << std::endl;
ar &= a;
ar &= b;
ar &= c;
}
};

class B : public Serializable<B>
{
int a;
int b;
public:
B() : a(4), b(5) { }

void serialize(Archi ve& ar)
{
std::cout << "Serializin g B" << std::endl;
ar &= a;
ar &= b;
}

};

class C : public A, public B, public Serializable<C>
{
int c;
int d;
public:
C() : c(6), d(7) { }

void serialize(Archi ve& ar)
{
std::cout << "Serializin g C" << std::endl;
ar &= c;
ar &= d;
}
};

class D : public B, public A, public Serializable<D>
{
int e;
int f;
int g;
public:
D() : e(4), f(5), g(6)
{

}

void serialize(Archi ve& ar)
{
std::cout << "Serializin g D" << std::endl;
ar &= e;
ar &= f;
ar &= g;
}
};

class E : public A, public C, public Serializable<E>
{
int e;
public:
E() : e(5) { }

void serialize(Archi ve& ar)
{
std::cout << "Serializin g E" << std::endl;
ar &= e;
}
};

/// T is the class that were're testing
template<class T>
void do_test(serial: :Archive& ar)
{
T c;

std::cout << "testing " << typeid(c).name( ) << std::endl;

Serial_holder sh(&c);
sh.serialize(ar );
}

int main()
{
serial::Archive ar;
do_test<E>(ar);

return 0;
}