Managed to recreate the binary serialization crash in 3 files
OS : Suse Linux
gcc : 4.2.1
Boost: 1.39
Files: RepeatAttr.hpp // only has an include for only the text
archive
RepeatAttr.cpp
TestSerialisation.cpp // include the main, and has
// includes for text and
binary archives
When the test is built there are no warnings on gcc, when the
test is run the text serialisation runs ok, but binary crashes
on serialising the base pointer.
To make the test pass uncomment out the binary archive
include in RepeatAttr.hpp and hey presto the test now passes.
//--------------------- RepeatAtrr.cpp --------------------
#include "RepeatAttr.hpp"
#include <sstream>
#include
using namespace std;
RepeatDate* RepeatDate::clone() const
{
return new RepeatDate(name_, start_, end_, delta_) ;
}
bool RepeatDate::compare(RepeatBase* rb) const
{
RepeatDate* rhs = dynamic_cast(rb);
if(!rhs) return false;
return operator==(*rhs);
}
bool RepeatDate::operator==(const RepeatDate& rhs) const
{
if (name_ != rhs.name_) return false;
if (start_ != rhs.start_) return false;
if (end_ != rhs.end_) return false;
if (delta_ != rhs.delta_) return false;
return true;
}
BOOST_SERIALIZATION_ASSUME_ABSTRACT(RepeatBase);
BOOST_CLASS_EXPORT(RepeatDate);
//--------------------- RepeatAtrr.hpp --------------------
#ifndef REPEATATTR_HPP_
#define REPEATATTR_HPP_
#include <ostream>
#include
#include
#include
//#include // If this is
UNCOMMENTED NO CRASH
//#include // If this is
UNCOMMENTED NO CRASH
#include
#include
#include
#include
class RepeatBase {
public:
RepeatBase() {}
virtual ~RepeatBase() {}
virtual RepeatBase* clone() const = 0;
virtual bool compare(RepeatBase*) const = 0;
virtual std::string name() const = 0;
private:
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive &, const unsigned int) {}
};
class RepeatDate : public RepeatBase {
public:
RepeatDate(
const std::string& variable,
int start,
int end,
int delta /* always in days*/
) : name_(variable), start_(start), end_(end), delta_(delta),
value_(start) {}
RepeatDate() : start_(0), end_(0), delta_(0), value_(0) {}
bool operator==(const RepeatDate& rhs) const;
virtual RepeatDate* clone() const ;
virtual std::string name() const { return name_;}
virtual bool compare(RepeatBase*) const;
private:
std::string name_;
int start_;
int end_;
int delta_;
long value_;
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int /*version*/) {
ar & boost::serialization::base_object<RepeatBase>(*this);
ar & name_;
ar & start_;
ar & end_;
ar & delta_;
ar & value_;
}
};
class Repeat {
public:
Repeat() : repeatType_(NULL) {}
Repeat( const RepeatDate& r) : repeatType_(new RepeatDate(r)) {}
~Repeat() { delete repeatType_;}
std::string name() const { return
repeatType_->name();}
bool operator==(const Repeat& rhs) const { return
repeatType_->compare(rhs.repeatType_); }
private:
RepeatBase* repeatType_;
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int /*version*/) {
ar & repeatType_;
}
};
#endif
//--------------------- TestSerialisation.cpp --------------------
#include "RepeatAttr.hpp"
#include
#include
#include
#include
#include
#include // no need to include <vector>
#include // no need to include <string>
#include <fstream>
#include <iostream>
#include // explicit code for exports
(place last)
class Suite {
public:
Suite( const std::string& name ) : name_(name), repeat_(NULL) {}
Suite() : repeat_(NULL) {}
virtual ~Suite() {}
const std::string& name() const { return name_; }
bool operator==(const Suite& rhs) const { return name_ == rhs.name_;}
bool addRepeat( const Repeat& r ) {
if (repeat_) return false;
repeat_ = new Repeat(r);
return true;
}
private:
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int /*version*/) {
ar & name_;
ar & repeat_;
}
std::string name_;
Repeat* repeat_;
};
BOOST_CLASS_EXPORT(Suite)
class Defs {
public:
Defs( const std::string& name ) : fileName_(name) {}
Defs() {}
~Defs() {}
const std::string& fileName() const { return fileName_;}
void fileName(const std::string& f) { fileName_ = f;}
void addSuite(std::auto_ptr<Suite> s){
suiteVec_.push_back(s.release()); }
bool operator==(const Defs& rhs) const {
if ( fileName_ != rhs.fileName_ ) return false;
if ( suiteVec_.size() != rhs.suiteVec_.size()) return false;
for(unsigned i =0; i < suiteVec_.size(); ++i) {
if ( !( *(suiteVec_[i]) == *(rhs.suiteVec_[i]) )) return false;
}
return true;
}
void save(bool binary) const
{
using namespace std;
if (binary) {
std::ofstream ofs( fileName_.c_str(), ios::binary );
boost::archive::binary_oarchive oa( ofs );
oa << *this;
}
else {
std::ofstream ofs( fileName_.c_str() );
boost::archive::text_oarchive oa( ofs );
oa << *this;
}
if (binary) cout << "Saved binary " << fileName_ << "\n";
else cout << "Saved text " << fileName_ << "\n";
}
void restore(bool binary)
{
using namespace std;
if (!fileName_.empty()) {
if (binary) {
std::ifstream ifs( fileName_.c_str(), ios::binary);
boost::archive::binary_iarchive ia(ifs);
ia >> (*this);
}
else {
std::ifstream ifs( fileName_.c_str());
boost::archive::text_iarchive ia(ifs);
ia >> (*this);
}
if (binary) cout << "Restored binary " << fileName_ << "\n";
else cout << "Restored text " << fileName_ << "\n";
}
}
private:
std::string fileName_;
std::vector suiteVec_;
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int /*version*/) {
ar & fileName_;
ar & suiteVec_;
}
};
int main()
{
{
// ***** TEXT This works
Defs saveDefs("saveFile.txt");
std::auto_ptr<Suite> suite(new Suite("s3") );
suite->addRepeat( RepeatDate("YMD",20090916,20090930,1));
saveDefs.addSuite( suite );
saveDefs.save(false);
Defs loadDefs(saveDefs.fileName());
loadDefs.restore(false);
assert( saveDefs == loadDefs );
}
{
// ****** BINARY This crashes
// ****** Uncomment the binary include in RepeatAttr.hpp and it
works
Defs saveDefs("saveFile.bin");
std::auto_ptr<Suite> suite(new Suite("s3") );
suite->addRepeat( RepeatDate("YMD",20090916,20090930,1));
saveDefs.addSuite( suite );
saveDefs.save(true);
Defs loadDefs(saveDefs.fileName());
loadDefs.restore(true);
assert( saveDefs == loadDefs );
}
std::cout << "reached the end\n";
return 0;
}
//-------------------------------------------------------------------------
Best regards,
Ta,
Avi
