#include <fstream>

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/nvp.hpp>

typedef std::vector<int> B;

class A;

typedef boost::shared_ptr<A> a_ptr;
typedef boost::shared_ptr<B> b_ptr;

class A{
public:
	A(){}
	A(b_ptr b) : b_(b){}
  virtual ~A(){}
  b_ptr b_;

  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
    ar & BOOST_SERIALIZATION_NVP(b_);
  }
};

class DA : public A{
public:
	DA(){}
	DA(b_ptr b) : A(b){}
	template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
		ar & boost::serialization::make_nvp("base", boost::serialization::base_object<A>(*this));
  }
};


typedef std::vector<a_ptr> VA;
typedef boost::shared_ptr<VA> va_ptr;

typedef std::vector<va_ptr> VVA;
typedef boost::shared_ptr<VVA> vva_ptr;

template <typename Archive>
void register_types(Archive& ar){
  ar.template register_type<DA>();
}

b_ptr make_b(){
	return b_ptr(new B);
}

a_ptr make_a(){
	return a_ptr(new DA(make_b()));
}

va_ptr make_va(){
	VA va;
	va.push_back(make_a());
	va.push_back(make_a());
	return va_ptr(new VA(va));
}

vva_ptr make_vva(){
	VVA vva;
	vva.push_back(make_va());
	vva.push_back(make_va());
	return vva_ptr(new VVA(vva));
}

int main(){
	std::string filename = "tmp";
	std::vector<vva_ptr> thing;
	thing.push_back(make_vva());
	thing.push_back(make_vva());
	{
		std::ofstream ofs(filename.c_str());
		boost::archive::binary_oarchive oa(ofs);
		register_types(oa);
		oa << BOOST_SERIALIZATION_NVP(thing);
	}
	{
		std::ifstream ifs(filename.c_str());
		boost::archive::binary_iarchive ia(ifs);
		register_types(ia);
		ia >> BOOST_SERIALIZATION_NVP(thing);
	}
	return 0;
}