Boost logo

Boost Users :

From: Benjamin Lau (blwy10v_at_[hidden])
Date: 2005-09-05 11:27:52


Here is my short [kind of?] example. If it is too long, sorry, but I
felt that I had to populate my vector with somewhat substantial
vector. Also, in my previous post, I said that the other types that
class Builder serialized only serialized std::string and booleans, but
they also serialize std::vector<std::string>. I don't think it would
make any difference since they are all either primitive types or types
defined by the standard, but just to clarify.

boost_serialization_test.hpp:
#ifndef DATA_CLASSES_H
#define DATA_CLASSES_H

#include <fstream>
#include <string>
#include <vector>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/shared_ptr.hpp>

class Program
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & sources;
                ar & target;
                ar & indent;
                ar & buildVars;
                ar & buildVarsValues;
        }

public:
        Program() : className("Program") { }
        std::string sources;
        std::string target;
        bool indent;
        std::vector<std::string> buildVars;
        std::vector<std::string> buildVarsValues;
        std::string className;
};

class Object
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & sources;
                ar & target;
                ar & indent;
                ar & buildVars;
                ar & buildVarsValues;
        }

public:
        Object() : className("Object") { }
        std::string className;
        std::string sources;
        std::string target;
        bool indent;
        std::vector<std::string> buildVars;
        std::vector<std::string> buildVarsValues;
};

class Java
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & srcDir;
                ar & classDir;
                ar & indent;
        }

public:
        Java() : className("Java") { }
        std::string className;
        std::string srcDir;
        std::string classDir;
        bool indent;
};

class Comment
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & content;
        }

public:
        std::string content;
};

class Print
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & content;
                ar & indent;
        }

public:
        Print() : className("Print") { }
        std::string className;
        std::string content;
        bool indent;
};

class Variable
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & name;
                ar & content;
                ar & indent;
        }

public:
        Variable() : className("Variable") { }
        std::string className;
        std::string name;
        std::string content;
        bool indent;
};

class Library
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & sources;
                ar & target;
                ar & indent;
                ar & buildVars;
                ar & buildVarsValues;
        }

public:
        Library() : className("Library") { }
        std::string className;
        std::string sources;
        std::string target;
        bool indent;
        std::vector<std::string> buildVars;
        std::vector<std::string> buildVarsValues;
};

class SharedLibrary
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & sources;
                ar & target;
                ar & indent;
                ar & buildVars;
                ar & buildVarsValues;
        }

public:
        SharedLibrary() : className("SharedLibrary") { }
        std::string className;
        std::string sources;
        std::string target;
        bool indent;
        std::vector<std::string> buildVars;
        std::vector<std::string> buildVarsValues;
};

class Node
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & nodes;
                ar & file;
                ar & dir;
                ar & content;
                ar & indent;
                ar & name;
        }

public:
        Node() : className("Node") { }
        std::string className;
        std::string nodes;
        std::string file;
        std::string dir;
        std::string content;
        bool indent;
        std::string name;
};

class Import
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & import;
        }

public:
        Import() : className("Import") { }
        std::string className;
        std::string import;
};

class Code
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & code;
                ar & indent;
        }

public:
        Code() : className("Code") { }
        std::string className;
        std::string code;
        bool indent;
};

class SourceSignatures
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & indent;
                ar & type;
        }

public:
        SourceSignatures() : className("SourceSignatures") { }
        std::string className;
        bool indent;
        std::string type;
};

class TargetSignatures
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & indent;
                ar & type;
        }

public:
        TargetSignatures() : className("TargetSignatures") { }
        std::string className;
        bool indent;
        std::string type;
};

class SetOption
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & indent;
                ar & option;
                ar & value;
        }

public:
        SetOption() : className("SetOption") { }
        std::string className;
        bool indent;
        std::string option;
        std::string value;
};

class Ignore
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & indent;
                ar & target;
                ar & file;
        }

public:
        Ignore() : className("Ignore") { }
        std::string className;
        bool indent;
        std::string target;
        std::string file;
};

class Depend
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & indent;
                ar & target;
                ar & file;
        }

public:
        Depend() : className("Depend") { }
        std::string className;
        bool indent;
        std::string target;
        std::string file;
};

class EnvironmentVariable
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & indent;
                ar & name;
                ar & buildVars;
                ar & buildVarsValues;
        }

public:
        EnvironmentVariable() : className("EnvironmentVariable") { }
        std::string className;
        bool indent;
        std::string name;
        std::vector<std::string> buildVars;
        std::vector<std::string> buildVarsValues;
};

class Builder
{
private:
        friend class boost::serialization::access;

        template<class Archive> void serialize(Archive & ar, const unsigned
int version)
        {
                ar & type;
                switch(type)
                {
                case 0:
                        ar & program;
                        break;
                case 1:
                        ar & object;
                        break;
                case 2:
                        ar & java;
                        break;
                case 3:
                        ar & comment;
                        break;
                case 4:
                        ar & print;
                        break;
                case 5:
                        ar & variable;
                        break;
                case 6:
                        ar & library;
                        break;
                case 7:
                        ar & sharedLibrary;
                        break;
                case 8:
                        ar & node;
                        break;
                case 9:
                        ar & import;
                        break;
                case 10:
                        ar & code;
                        break;
                case 11:
                        ar & sourceSignatures;
                        break;
                case 12:
                        ar & targetSignatures;
                        break;
                case 13:
                        ar & setOption;
                        break;
                case 14:
                        ar & ignore;
                        break;
                case 15:
                        ar & depend;
                        break;
                case 16:
                        ar & environmentVariable;
                        break;
                }
        }
        
public:
        boost::shared_ptr<Program> program;
        boost::shared_ptr<Object> object;
        boost::shared_ptr<Java> java;
        boost::shared_ptr<Comment> comment;
        boost::shared_ptr<Print> print;
        boost::shared_ptr<Variable> variable;
        boost::shared_ptr<Library> library;
        boost::shared_ptr<SharedLibrary> sharedLibrary;
        boost::shared_ptr<Node> node;
        boost::shared_ptr<Import> import;
        boost::shared_ptr<Code> code;
        boost::shared_ptr<SourceSignatures> sourceSignatures;
        boost::shared_ptr<TargetSignatures> targetSignatures;
        boost::shared_ptr<SetOption> setOption;
        boost::shared_ptr<Ignore> ignore;
        boost::shared_ptr<Depend> depend;
        boost::shared_ptr<EnvironmentVariable> environmentVariable;
        int type;
};
/*
BOOST_CLASS_TRACKING(Program, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Object, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Java, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Comment, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Print, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Variable, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Library, boost::serialization::track_never)
BOOST_CLASS_TRACKING(SharedLibrary, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Node, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Import, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Code, boost::serialization::track_never)
BOOST_CLASS_TRACKING(SourceSignatures, boost::serialization::track_never)
BOOST_CLASS_TRACKING(TargetSignatures, boost::serialization::track_never)
BOOST_CLASS_TRACKING(SetOption, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Ignore, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Depend, boost::serialization::track_never)
BOOST_CLASS_TRACKING(EnvironmentVariable, boost::serialization::track_never)
BOOST_CLASS_TRACKING(Builder, boost::serialization::track_never)*/

#endif

boost_serialization_test.cpp:
#include "boost_serialization_test.hpp"

int main()
{
        std::ofstream fout("file");
        boost::archive::text_oarchive fout_ar(fout);
        std::vector<Builder> data;
        Builder *builder = new Builder[10];
        for(int i = 0; i < 10; i++)
        {
                builder[i].type = i;
                switch(i)
                {
                case 0:
                        builder[i].program->sources = "bshfdvhjvcds";
                        break;
                case 1:
                        builder[i].object->sources = "bshfdvhjvcds";
                        break;
                case 2:
                        builder[i].java->srcDir = "bshfdvhjvcds";
                        break;
                case 3:
                        builder[i].comment->content = "bshfdvhjvcds";
                        break;
                case 4:
                        builder[i].print->content = "bshfdvhjvcds";
                        break;
                case 5:
                        builder[i].variable->content = "bshfdvhjvcds";
                        break;
                case 6:
                        builder[i].library->sources = "bshfdvhjvcds";
                        break;
                case 7:
                        builder[i].sharedLibrary->sources = "bshfdvhjvcds";
                        break;
                case 8:
                        builder[i].node->content = "bshfdvhjvcds";
                        break;
                case 9:
                        builder[i].import->import = "bshfdvhjvcds";
                        break;
                case 10:
                        builder[i].code->code = "bshfdvhjvcds";
                        break;
                case 11:
                        builder[i].sourceSignatures->type = "jsdbifbviugvdbuyvf";
                        break;
                case 12:
                        builder[i].targetSignatures->type = "jsdbifbviugvdbuyvf";
                        break;
                case 13:
                        builder[i].setOption->option = "jsdbifbviugvdbuyvf";
                        break;
                case 14:
                        builder[i].ignore->target = "jsdbifbviugvdbuyvf";
                        break;
                case 15:
                        builder[i].depend->target = "jsdbifbviugvdbuyvf";
                        break;
                case 16:
                        builder[i].environmentVariable->name = "vhdbfubvugvsdfuvy";
                        break;
                }
        }
        for(int i = 0; i < 10; i++)
        {
                data.push_back(builder[i]);
        }
        fout_ar << data;
}

Thanks a lot.

Benjamin Lau

P/s By the way, the /**/ around the BOOST_CLASS_TRACKING were from an
earlier attempt to correct the problem, but with or without the
macros, the same error messages appear.


Boost-users list run by williamkempf at hotmail.com, kalb at libertysoft.com, bjorn.karlsson at readsoft.com, gregod at cs.rpi.edu, wekempf at cox.net