Re: [Boost-users] boost 1.39 serialization via base pointer ok ongcc, but crashes on AIX V10.1

Subject: Re: [Boost-users] boost 1.39 serialization via base pointer ok ongcc, but crashes on AIX V10.1
From: Robert Ramey (ramey_at_[hidden])
Date: 2009-07-24 10:18:11

If this is what I think it is, it might be already fixed in the trunk.

Robert Ramey
  "Avi Bahra" <avibahra_at_[hidden]> wrote in message news:af1b101f0907240113q2b66898dp368987a2cccb5a06_at_mail.gmail.com...
  Ok first I hadn't realised my attachment was removed. So I include the
  source code below. This is small and self contained.

  o The compile error on AIX was removed because I saving via a non const
    variable. ( Note however gcc 4.2.1. on Linux it did not complain.)

  o To recap this compiles and runs on Linux with gcc 4.2.1 but
    crashes/exception on AIX V10.1. Because it reckons the derived/base
    relationship has not been registered.
               ... oserializer.hpp
               // convert pointer to more derived type. if this is thrown
               // it means that the base/derived relationship hasn't be registered
               vp = serialization::void_downcast(
                   *true_type, 
                   *this_type, 
                   static_cast<const void *>(&t)
               );
               if(NULL == vp){
                   boost::serialization::throw_exception(
     >>>>         archive_exception(archive_exception::unregistered_cast)
                   );
               }

     Note if a save via the derived ptr, then it works.

  o If I explicitly register this relationship, (see code below)
    Then I get past the first exception only to get an assert.

               // since true_type is valid, and this only gets made if the 
               // pointer oserializer object has been created, this should never
               // fail
               const basic_pointer_oserializer * bpos 
                   = archive_pointer_oserializer<Archive>::find(* true_type);
   >>>     assert(NULL != bpos);
               if(NULL == bpos)
                   boost::serialization::throw_exception(
                       archive_exception(archive_exception::unregistered_class)
                   );
               ar.save_pointer(vp, bpos);

  o Initially I thought it was compiled without rtti on AIX.
    However this was not the case. Here is compile line.
     xlC -c   -DDEBUG -qcpluscmt -qNOOPTimize -qnoinline -g 
              -qfullpath 
              -qfuncsect 
              -qeh 
              -qrtti 
              -qtemplatedepth=700 
              -I"../SCRATCH/src" -I"/s1a/emos_esuite/emos_data/sms/boost_1_39_0"  
              -o "bin/vacpp/debug/src/TestSerialisation.o" 
              "src/TestSerialisation.cpp"

   This is show stopper bug that I must get fixed.
   Are there any more things I can try to debug this ?

   Any help would be much appreciated.

  //=============== the example ========================
  #include <fstream>
  #include <assert.h>
  #include <boost/archive/text_iarchive.hpp>
  #include <boost/archive/text_oarchive.hpp>
  #include <boost/serialization/base_object.hpp>
  #include <boost/serialization/string.hpp>         
  #include <boost/serialization/export.hpp>     

  class RepeatBase {
  public:
     RepeatBase() {}
     virtual ~RepeatBase() {}
     virtual const std::string& name() const = 0;
  private:
     friend class boost::serialization::access;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version) {}
  };

  class RepeatDerived : public RepeatBase {
  public:
     RepeatDerived( const std::string& name) : name_(name) {}
     RepeatDerived()  {}
     virtual const std::string& name() const { return name_;}
  private:
     std::string  name_;
     friend class boost::serialization::access;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version) {
            // save/load base class information
            ar & boost::serialization::base_object<RepeatBase>(*this);
            ar & name_;
     }
  };

  class Defs {
  public:
     Defs(const std::string& f) : fileName_(f), repeat_(new RepeatDerived(f)) {}
     Defs() : repeat_(NULL) {}
     ~Defs() { delete repeat_;}
     bool operator==(const Defs& rhs) const { return fileName_ == rhs.fileName_;}

     const std::string& fileName() const { return fileName_;}

  private:
     std::string fileName_;
     RepeatBase* repeat_;

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

  BOOST_CLASS_EXPORT(RepeatBase);
  BOOST_CLASS_EXPORT(RepeatDerived);
  BOOST_SERIALIZATION_ASSUME_ABSTRACT(RepeatBase)

  int main()
  {
     // With this explicit register, we get a bit further, but still crashes on AIX
     // boost::serialization::void_cast_register<RepeatDerived, RepeatBase>(0,0);

     const Defs saveDefs("saveFile.txt");
     {
             // Save the defs file
             std::ofstream ofs( saveDefs.fileName().c_str() );
             boost::archive::text_oarchive oa( ofs );
             oa << saveDefs;                                             // BOMBS out here on AIX V10.1
     }
     {
           // Restore the defs file
           Defs loadDefs;
           std::ifstream ifs(saveDefs.fileName().c_str());
           boost::archive::text_iarchive ia(ifs);
           ia >> loadDefs;

           assert( saveDefs == loadDefs );
     }
     return 0;
  }
  //===============================================
    Best regards,
  Ta,
     Avi

------------------------------------------------------------------------------

  _______________________________________________
  Boost-users mailing list
  Boost-users_at_[hidden]
  http://lists.boost.org/mailman/listinfo.cgi/boost-users