nico wrote:
Hello.
I've already posted this topic in the boost-user mailing list, but no reply: maybe this boost list is more active... ? Anyway:
I use boost.serialization to perform save and load to files. If a class is serializable through the boost mechanism, I'd like to easily add the "savable" feature (through serialization and boost archives).
I think this is misguided. Including the serialize functions is all you need to make the class "saveable". Adding something besides would be redundent.
Here how I do, and then I've got 2 questions. I don't post all the #include statements.
Let's have a serializable class (I only use text archive for this example)
---------MyClass.h---------
class MyClass { friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version);
int data_;
public: MyClass(); virtual ~MyClass();
};
BOOST_CLASS_EXPORT_KEY(MyClass)
I would not include the above macro unless you know you expect to serialize though a base class pointer.
---------MyClass.cpp---------
MyClass::MyClass() : data_(123) {} MyClass::~MyClass() {}
template<class Archive> void MyClass::serialize(Archive & ar, const unsigned int version) { ar & data_;
}
// instanciate the serialize function for text archives #include "boost/archive/text_iarchive.hpp" #include "boost/archive/text_oarchive.hpp" template void MyClass::serialize(boost::archive::text_iarchive & ar, const unsigned int version); template void MyClass::serialize(boost::archive::text_oarchive & ar, const unsigned int version); BOOST_CLASS_EXPORT_IMPLEMENT(MyClass)
---------
Now I define a FileSavable class. Its purpose is to add the "save-to-file" feature to a class that can be serialized in a text archive, making the latter inherting from FileSavable, and adding a line in its serialize function, I write it below).
---------FileSavable.h---------
class FileSavable { friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version);
public: virtual ~FileSavable() {} void SaveToFile(std::string path); void LoadFromFile(std::string path);
};
BOOST_CLASS_EXPORT_KEY(FileSavable)
---------FileSavable.cpp---------
template<class Archive> void FileSavable::serialize(Archive & ar, const unsigned int version) {}
void FileSavable::SaveToFile(std::string path) { std::ofstream ofs(path.c_str()); assert(ofs.good()); boost::archive::text_oarchive oa(ofs); oa & this;
}
void FileSavable::LoadFromFile(std::string path) { std::ifstream ifs(path.c_str()); assert(ifs.good()); boost::archive::text_iarchive ia(ifs); FileSavable* p; ia & p; *this = *p; delete p;
}
If you REALLY want something like this, consider something like the following: template<class T> void FileSave(const std::string & path, const T & t){ std::ofstream ofs(path.c_str()); boost::archive::text_oarchive oa(ofs); oa << t; } ... then you instead of MyClass t; FileSave(path, t); you would say FileSave(path, t); And if you REALLY want the first syntax you could at the above FileSave template as a member to each serialization class void FileSave(const std::string & path{ std::ofstream ofs(path.c_str()); boost::archive::text_oarchive oa(ofs); oa << *this; } ... I'm not sure what else to say about this. Robert Ramey
// instanciate the serialize function for text archives #include "boost/archive/text_iarchive.hpp" #include "boost/archive/text_oarchive.hpp" template void FileSavable::serialize(boost::archive::text_iarchive & ar, const unsigned int version); template void FileSavable::serialize(boost::archive::text_oarchive & ar, const unsigned int version); BOOST_CLASS_EXPORT_IMPLEMENT(FileSavable)
---------Modification to MyClass--------- It now inherit from FileSavable:
class MyClass : public FileSavable
The serialize function call the base class:
template<class Archive> void MyClass::serialize(Archive & ar, const unsigned int version) { ar & boost::serialization::base_object<FileSavable>(*this); ar & data_;
}
---------
Thanks if you read me until here, now my questions:
1) I don't care the FileSavable part of MyClass being serialized, but if I don't call it with boost::serialization::base_object, I have a runtime error: terminate called after throwing an instance of 'boost::archive::archive_exception' what(): unregistered void cast 7MyClass<-11FileSavable Do you see a way to avoid having to add this line in MyClass? Ideally, just having to inheriting from FileSavable would be great: a simple way to add a feature.
2) As you can see, my LoadFromFile function first creates a new MyClass object in p, by de-serializing an archive, and then copies this newly created object into "*this", and finally deletes the object created by the archive d-eserialization. I didn't find a way to avoid this temporary and de-serialize directly in this. Moreover, my solution is not exception-safe, but I didn't manage to de-serialize in a temporary auto_ptr nor boost::shared_ptr.
Thanks in advance for replies.
Nicolas. _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost