[Boost-users] Fwd: Serializing of object with map and multimap. Questions.

5 Nov 2009

      I have sent a couple of questions to this list in the past week and haven't
gotten a single response.  Wondering if my messages are being bounced???

---------- Forwarded message ----------
From: B Hart <bhartsb@gmail.com>
Date: Wed, Nov 4, 2009 at 3:42 PM
Subject: Serializing of object with map and multimap. Questions.
To: Boost-users@lists.boost.org

I've been having some problems storing and loading a class with a map and a
multimap.  The map contains values that are simple objects of another
class.  My questions are below.  Here is also a link to the same question
posted on stackoverflow.
Thanks.

http://stackoverflow.com/questions/1676781/boost-serializing-of-object-conta...

See below a main() and two very simple classes. Then per Boost serialization
(and what is shown) my questions are:

1) Does class B need the normal overloaded stream insertion operators '<<'
and '>>' to be defined? Currently in my real code it doesn't have these.

2) Does class A in the store() and load() methods need to iterate through
the map and multimap containers explicitly, storing/loading their key:value
pairs explicitely? e.g. something like:

void A::store(const char* filename){

std::ofstream ofs(filename);
boost::archive::text_oarchive oa(ofs);

std::map< std::string, B >::iterator it;

BMap.size();
oa << BMap.size();
for( it = BMap.begin(); it != BMap.end(); it++ ){

        oa <<  it->first;
        oa << it->second;
}

//similar for strMultimap
}

I assume that I don't need to do this, but am not certain.

3) Assuming class B has only the two data members shown, does it need a
default contructor included explicitely? (as opposed to the implicit default
constructor)

4) Does B need to have an overide for the comparison operator '>'? I assume
that it doesn't since this is a very simple class.

Finally, any other comments per anything that I've failed to cover is
appreciated!

Example code for my above questions:

//includes ommitted

int main() {

    std::string file("test.dat");

    A * pA = new A;

    pA->store(file.c_str());

    pA->fillMaps();
    //release data
    pA->load(file.c_str());

    return 0;
}

//includes ommitted

class A
{
    friend class boost::serialization::access;

public:

    std::map< std::string, B > BMap;

    std::multimap< std::string, std::string > strMultimap;

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

    {
        ar & BMap;
        ar & strMultimap;

    }

    void store(const char* filename){

    std::ofstream ofs(filename);
    boost::archive::text_oarchive oa(ofs);

    oa << this;
  }

  void load(const char* filename){

    std::ifstream ifs(filename);
    boost::archive::text_iarchive ia(ifs);

    ia >> this;

  }

  void fillMaps(){

//code to allocate B objects and put them in BMap and fill strMultimap
with whatever number of key:value pairs

}

class B
{
friend class boost::serialization::access;

public:

    std::string str;

    unsigned int num;

    B::B(void)

    : str("a string")
    , num(7)

    {
    }

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {
        ar & str;
        ar & num;

    }
}