Hi everybody.I'm having problems understanding the Boost::Serialization library. I've managed to get it to save my object... but once I try to load them in to the code doesn't compile. It fails on the line where the ifstream writes to the object. Basically what I'm trying to do is to save a hierarchy of objects that build up a filesystem namespace for a virtual filesystem I'm trying to code. It's something like this: Filesystem_NS --> fsFile -->--> fsFileChunk -->--> fsFileChunk --> fsFile -->--> fsFileChunk -->--> fsFileChunk The code isn't commented very well but it's nothing more than saving and loading the data structures at the moment. There is no code/methods note: There are more errors but they're so many that the forum doesn't allow me to post all of them because of a character limit It looks there's a problem that I'm boost::shared_ptr or something... I don't know I've been probably looking at this for too long. The code compiles if I remove the line where it loads the fsImage file back in to an object. Note that it does save properly. That is, I believe all the data shows up in the saved archive although I can't be sure unless I'm able to restore the state. Could someone here give me a hand? *hdfs.cpp* Code: #ifdef HAVE_CONFIG_H #include #endif #include <iostream> #include <fstream> #include <cstdlib> #include <utility> #include "FileSystem.h" #include "fstypes.h" #include "fsFile.h " #include "fsFileChunk.h" #include #include #include #include #include #include using namespace std; int main(int argc, char *argv[]) { // string s1 = Path::normalizePath("http://asdfasd/fasdfa//asdf//"); string fsPath = "./fsImage"; FileSystem_NS * const fs = new FileSystem_NS(fsPath); fileId_t fid = ++(*fs).nextFileId; fsFile_Ptr ff(new fsFile(fid)); (*fs).files.insert(pair("biomynd",ff)); chunkVersion_t cv = 1; size_t cs = 67108864; fsFileChunk_Ptr fc(new fsFileChunk(++(*fs).nextChunkId, (*ff).fID, cv, cs)); ff->addChunk(fc); ofstream ofs("./fsImage"); { boost::archive::text_oarchive oa(ofs); // write class instance to archive oa << (const FileSystem_NS)(*fs); // archive and stream closed when destructors are called } ofs.close(); FileSystem_NS const *newFilesystem = new FileSystem_NS("lol"); ifstream ifs("./fsImage"); { // open the archive boost::archive::text_iarchive ia(ifs); // restore the schedule from the archive ia >> (*newFilesystem); } ifs.close(); cout << fs->fsImage_Path << endl; return EXIT_SUCCESS; } *FileSystem.h* Code: /************************************************************************ FileSystem.h - Copyright Hannes Baldursson **************************************************************************/ #ifndef FILESYSTEM_H #define FILESYSTEM_H #include "fstypes.h" #include "fsFile.h" #include "fsFileChunk.h" #include <string> #include <map> #include <vector> #include #include #include #include #include #endif #include <iostream> #include <fstream> #include <cstdlib> #include <utility> #include "FileSystem.h" #include "fstypes.h" #include "fsFile.h" #include "fsFileChunk.h" #include #include #include #include #include #include using namespace std; int main(int argc, char *argvon/tracking.hpp> #include using namespace std; // Filesystem namespace class FileSystem_NS { public: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) const { ar & nextFileId; ar & nextChunkId; ar & files; } fileId_t nextFileId; chunkId_t nextChunkId; const string fsImage_Path; FileSystem_NS(string fsImage = "./fsImage"); map files; // Maps filenames to fileIds }; BOOST_CLASS_TRACKING(FileSystem_NS, boost::serialization::track_always) #endif // FILESYSTEM_H *fsFile.h* Code: #ifndef FSFILE_H #define FSFILE_H #include <string> #include <map> #include "fstypes.h" #include "fsFileChunk.h" #include #include using namespace std; class fsFile { public: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) const { ar & fname; ar & fID; ar & chunks; } string fname; fileId_t fID; vector chunks; // Create a fsFile fsFile(fileId_t fileID); void addChunk(fsFileChunk_Ptr ptr); }; typedef boost::shared_ptr<fsFile> fsFile_Ptr; BOOST_CLASS_TRACKING(fsFile, boost::serialization::track_always) #endif *fsFileChunk.h* Code: #ifndef FSFILE_CHUNK_H #define FSFILE_CHUNK_H #include <vector> #include <string> #include "fstypes.h" #include #include #include using namespace std; class fsFileChunk { public: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) const { ar & cID; ar & fID; ar & cVersion; ar & cSize; } chunkId_t cID; fileId_t fID; // This chunk belongs to file "fileID" chunkVersion_t cVersion; // Current version size_t cSize; std::vector<string> hosts; // vector of hostIP:port for the datanodes that host this chunk. fsFileChunk(chunkId_t chunkID, fileId_t fileID, chunkVersion_t chunkVersion, size_t chunkSize); }; typedef boost::shared_ptr<fsFileChunk> fsFileChunk_Ptr; BOOST_CLASS_TRACKING(fsFileChunk, boost::serialization::track_always) #endif // FSFILE_CHUNK_H *fstypes.h* Code: #ifndef COMMON_FSTYPES_H #define COMMON_FSTYPES_H #include typedef unsigned long long fileId_t; typedef unsigned long long chunkId_t; typedef unsigned int chunkVersion_t; #endif These are all the header files plus the "main program". Code: /usr/lib/gcc/x86_64-pc-linux-gnu/4.1.2/include/g++-v4/istream:231: note: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>] <near match> /home/hannson/Projects/HDFS/src/boost/serialization/access.hpp: In static member function 'static void boost::serialization::access::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive, T = const std::map, boost::shared_ptr<fsFile>, std::less >, std::allocator

, boost::shared_ptr<fsFile> > > >]': /home/hannson/Projects/HDFS/src/boost/serialization/serialization.hpp:81: instantiated from 'void boost::serialization::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive, T = const std::map, boost::shared_ptr<fsFile>, std::less >, std::allocator > >]' /home/hannson/Projects/HDFS/src/boost/serialization/serialization.hpp:140: instantiated from 'void boost::serialization::serialize_adl(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive, T = const std::map, boost::shared_ptr<fsFile>, std::less >, std::allocator > >]' /home/hannson/Projects/HDFS/src/boost/archive/detail/iserializer.hpp:158: instantiated from 'void boost::archive::detail::iserializer::load_object_data(boost::archive::detail::basic_iarchive&, void*, unsigned int) const [with Archive = boost::archive::text_iarchive, T = const std::map, boost::shared_ptr<fsFile>, std::less >, std::allocator > >]' /home/hannson/Projects/HDFS/src/hdfs.cpp:70: instantiated from here /home/hannson/Projects/HDFS/src/boost/serialization/access.hpp:109: error: 'const class std::map, boost::shared_ptr<fsFile>, std::less >, std::allocator

These are not all the error messages I get.. One important thing. I'm clearly missing something because even when I comment out the fsFile part from the serialization (that is I'm only saving nextFileId and nextChunkId in FileSystem_NS) it still doesn't compile when I'm including the loading code so it seems I'm having two problems. One problem is restoring the object in general, and the other is restoring the objects when using a shared_ptr. Btw, sorry about the html if you like it plain :)