serialization of std::map which has member of boost::shared_ptr type fails

Question

I'm trying to compare two maps after serialization and deserialization of struct type. It gives me error -- "error in "MyExample": check e1_i1->second == e2_i1->second failed".

I'm not able to figure out what could be wrong in below code :

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/map.hpp> 
#include <boost/serialization/shared_ptr.hpp>

struct A
{
public:
   std::string oldname;
   std::string newname;

   friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
         ar & oldname;
         ar & newname;
      }
};

struct Example
{
public:
   bool check;
   std::map<std::string,boost::shared_ptr<A>> Atype;

   private:
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
         ar & check;
         ar & Atype;
      }
};

void set_data(boost::shared_ptr<A> e)
{
    e->oldname="a";
    e->newname="b";
}

void set_data(Example *e)
{
   e->check=false;

   // to initialize e->Atype
   boost::shared_ptr<A> a1 (new A());
   set_data(a1);
   e->Atype.insert(std::make_pair("a",a1));
}

void compare_data(std::map<std::string,boost::shared_ptr<A>> e1,std::map<std::string,boost::shared_ptr<A>> e2)
{
   // because it is of type map, it may be not in proper order   
   typedef std::map<std::string,boost::shared_ptr<A>>::const_iterator i1;

   i1 e1_i1= e1.begin();
   i1 e2_i1 =e2.begin();

   while ( e1_i1 != e1.end() && e2_i1 != e2.end()) 
   {
      BOOST_CHECK( e1_i1->first == e2_i1->first);

      const std::string &key = e1_i1->first;
      e2_i1 =e2.find(key);
      BOOST_CHECK(e1_i1->second == e2_i1->second);

      e1_i1++;
      e2_i1++;
    }
}

void compare_data(Example *e1,Example *e2)
{
   BOOST_CHECK(e1->check == e2->check);

   // need to compare e1->Atype with e2->Atype
   compare_data(e1->Atype,e2->Atype);
}

BOOST_AUTO_TEST_CASE(MyExample)
{
   boost::archive::text_oarchive ao(std::cout);

   Example c;
   set_data(&c);

   const Example & oc=c;
   ao << oc;

   std::stringstream ss; 
   boost::archive::text_oarchive oa(ss);
   oa << oc;

   boost::archive::text_iarchive ia(ss);

   Example d;
   ia >> d;

   compare_data(&c,&d); 

}

I have made sure to include all the header files but here I have not included all. Really not sure what could be wrong in above code either setting value of data is incorrect or comparison might be wrong.

different methods for initializing the map which I tried:

// e->Atype=map_list_of ("a",a1);
// e->Atype.insert(std::make_pair("a",a1));
// e->Atype.insert(std::map<std::string,boost::shared_ptr<A>>::value_type("a",a1));
// e->Atype["a"]=a1;

Thanks,

i tried different type of initialization of map.. but still issue exists as given in above code. — sia, May 02 '14 at 02:58
below link also did not help - http://stackoverflow.com/questions/1676781/boost-serializing-of-object-containing-map-with-object-values-and-multimap-wi — sia, May 02 '14 at 04:05
Have you checked the contents of the maps/shared pointers using a debugger? — dutt, May 02 '14 at 04:50
@dutt - yes.. issue is at BOOST_CHECK(e1_i1->second == e2_i1->second); both show different address location instead of looking for value.. — sia, May 02 '14 at 04:51
Please make your samples self-contained. This one was close, but people shouldn't know how to link Boost Test (and include the header) to run it: http://coliru.stacked-crooked.com/a/6e3fc9193e49b6bd — sehe, May 02 '14 at 16:20

6502 · Answer 1 · 2014-05-02T06:13:35.790

3

Your code for comparison should be changed to

void compare_data(const std::map<std::string,boost::shared_ptr<A>>& e1,
                  const std::map<std::string,boost::shared_ptr<A>>& e2)
{
   // because it is of type map, order IS guaranteed
   typedef std::map<std::string,boost::shared_ptr<A>>::const_iterator i1;

   i1 e1_i1= e1.begin();
   i1 e2_i1 =e2.begin();
   while ( e1_i1 != e1.end() && e2_i1 != e2.end()) 
   {
      BOOST_CHECK( e1_i1->first == e2_i1->first );
      if (e1_i1->second) {
         // Data value is present on e1, must be present on e2 too
         BOOST_CHECK( e2_i1->second );
         // The two data values must be equal
         BOOST_CHECK( *e1_i1->second == *e2_i1->second ); // Note the *
      } else {
         // Data value is not present on e1, must not be present in e2 either
         BOOST_CHECK( !e2_i1->second );
      }
      e1_i1++;
      e2_i1++;
   }
   // The iteration must terminate at the same time for e1 and e2
   // (i.e. neither of them must have extra elements in respect to the other)
   BOOST_CHECK( e1_i1 == e1.end() && e2_i1 == e2.end() );
}

You should also provide a bool operator==(const A& other) const to class A to check if two instances of A have the same value.

When deserializing it doesn't make sense to require that objects get allocated in the same memory address, it make sense only to see if the re-loaded value is the same.

edited May 02 '14 at 06:13

answered May 02 '14 at 06:02

6502

112,025
15
165
265

any reference link for to provide bool operator for class A. I'm just trying the above code – sia May 02 '14 at 06:05
@sia: it's just plain impossible that the error is that `e1_i1->second == e2_i1->second failed` because that comparison is not present in my version at all. Note the `*`. – 6502 May 02 '14 at 06:25
yes it is failing at my end.. if you want i can attach test log also – sia May 02 '14 at 06:29
I compiled your code after replacing the compare version with my version and providing the needed `A::operator==` and it works as expected. Kind of shocking for me too because it's the first time I ever tried to compile anything using boost and just worked (except some trouble to find the correct link command). – 6502 May 02 '14 at 06:56
- could you please share your version of code.. just want to compare it with my version – sia May 02 '14 at 06:58
@sia: http://pastebin.com/yYMeGgWU (note that operator== should be const... just noted I forgot that; works anyway but a non-const comparison is really weird). – 6502 May 02 '14 at 07:02
let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/51861/discussion-between-sia-and-6502) – sia May 02 '14 at 07:09
saw the code.. u hv implemented BOOST_CHECK.. there is no need for it.. boost has buil-in BOOST_CHECK macro.. please refer http://www.boost.org/doc/libs/1_34_0/libs/test/doc/components/test_tools/reference/BOOST_CHECK.html – sia May 02 '14 at 07:14

sehe · Accepted Answer · 2014-05-02T16:24:13.443

You're confused.

// because it is of type map, it may be not in proper order

On the contrary, map is an ordered container, and the invariant is precisely that elements are always in proper order.

The serialization is fine: Coliru prints the same data twice:

22 serialization::archive 10 0 0 0 0 0 1 0 0 0 1 a 0 1 4 1 0
0 1 a 1 b

22 serialization::archive 10 0 0 0 0 0 1 0 0 0 1 a 0 1 4 1 0
0 1 a 1 b

So it's the comparison that's broken. Fix it:

MapOfA mapOfA;

bool operator==(Example const& other) const {
    return (check == other.check)
        && (mapOfA.size() == other.mapOfA.size())
        && (mapOfA.end() == std::mismatch(
                mapOfA.begin(), mapOfA.end(),
                other.mapOfA.begin(),
                &ComparePair
        ).first);
}

private:
typedef MapOfA::value_type Pair;
static bool ComparePair(Pair const& a, Pair const& b) {
    bool ok = (a.first == b.first);
    if (a.second || b.second)
        ok &= (a.second && b.second) && (*a.second == *b.second);
    return ok;
}

You'll see that the whole program gets much smaller and less error-prone when you don't use pointers and helper functions all around. Instead, use **const& references and standard idioms/algorithms wherever you can.

Here's a version of your program in 97 lines Live On Coliru.

Full Listing

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/map.hpp> 
#include <boost/serialization/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <sstream>

struct A
{
    std::string oldname;
    std::string newname;

    A(std::string oldname = "", std::string newname = "") 
        : oldname(std::move(oldname)), newname(std::move(newname)) 
    { }

    bool operator==(A const& other) const {
        return (oldname == other.oldname)
            && (newname == other.newname);
    }

    friend class boost::serialization::access;
    template<class Archive>
        void serialize(Archive &ar, unsigned) {
            ar & oldname;
            ar & newname;
        }
};

struct Example
{
    typedef std::map<std::string, boost::shared_ptr<A> > MapOfA;

    bool check;
    MapOfA mapOfA;

    bool operator==(Example const& other) const {
        return (check == other.check)
            && (mapOfA.size() == other.mapOfA.size())
            && (mapOfA.end() == std::mismatch(
                    mapOfA.begin(), mapOfA.end(),
                    other.mapOfA.begin(),
                    &ComparePair
            ).first);
    }

  private:
    typedef MapOfA::value_type Pair;
    static bool ComparePair(Pair const& a, Pair const& b) {
        bool ok = (a.first == b.first);
        if (a.second || b.second)
            ok &= (a.second && b.second) && (*a.second == *b.second);
        return ok;
    }

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive &ar, unsigned) {
        ar & check;
        ar & mapOfA;
    }
};

template <typename T>
std::string to_string(T const& o) {
    std::stringstream ss; 
    boost::archive::text_oarchive oa(ss);
    oa << o;
    return ss.str();
}

int main()
{
    Example const data = {
        false,
        { { "ONE", boost::make_shared<A>("old one","new one") },
          { "TWO", boost::make_shared<A>("old two","new two") },
          { "TRHEE", boost::make_shared<A>("old three","new three") },
        }
    };

    std::string const original = to_string(data);

    std::cout << original << "\n";

    {
        std::stringstream ss(original); 
        boost::archive::text_iarchive ia(ss);

        Example roundtrip;
        ia >> roundtrip;

        std::string const verification = to_string(roundtrip);

        std::cout << std::boolalpha;
        std::cout << "Matching: "   << (data == roundtrip)        << "\n";
        std::cout << "Serialized: " << (verification == original) << "\n";
    }
}

thanks..really worked.. i missed adding bool operator== in Example struct.. i had added in struct A only.. — sia, May 05 '14 at 05:33

serialization of std::map which has member of boost::shared_ptr type fails

2 Answers2

Full Listing