Ticket #5299: s11n_bug.cpp

#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;
}