Boost logo

Boost Users :

Subject: [Boost-users] Strange issue with Serialization of BiMaps
From: Mangal (mangalmanish_at_[hidden])
Date: 2010-01-01 01:00:37

I am using Boost 1.40.0 and stlport 5.0 on Visual Studio 2008.
The Bimap deserialization succeeds for 24 elements but starts failing after

Here is the file with all the code

#include "stdafx.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/functional/hash.hpp>
#include <boost/bimap/bimap.hpp>
#include <fstream>
#include <exception>
#include <iostream>

using namespace boost;
using namespace boost::bimaps;

typedef unsigned int uint;

struct GeoNode
        GeoNode(uint x, uint y ): x_geocode(x), y_geocode(y) {}

        friend bool operator==(GeoNode const& a, GeoNode const& b)
        return a.x_geocode == b.x_geocode && a.y_geocode == b.y_geocode;

        friend std::size_t hash_value(GeoNode const& g)
        std::size_t seed = 0;
        boost::hash_combine(seed, g.x_geocode);
        boost::hash_combine(seed, g.y_geocode);

        return seed;

        friend bool operator < (GeoNode const& a, GeoNode const& b)
                if (a.x_geocode != b.x_geocode)
                        return a.x_geocode < b.x_geocode;

                return a.y_geocode < b.y_geocode;

        friend std::ostream& operator << (std::ostream& os, const GeoNode& g)
                os<<"X: "<<g.x_geocode<<" Y: "<<g.y_geocode<<std::endl;
                return os;


        friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
        ar & x_geocode;
        ar & y_geocode;


        uint x_geocode;
        uint y_geocode;

template< class MapType >
void print_map(const MapType & m)
    typedef typename MapType::const_iterator const_iterator;
    for( const_iterator iter = m.begin(), iend = m.end(); iter != iend;
++iter )
        std::cout << iter->first << "-->" << iter->second << std::endl;

int _tmain(int argc, _TCHAR* argv[])
        typedef bimap<uint, GeoNode> Store_type;
        const char* fileName = "Nodes.dat";
        Store_type storeToWrite;
        Store_type storeThatsRead;

        int countThatWorks = 24;
        int countThatFails = 25;
        //insert Data
        for ( int i =0;i<countThatFails;++i)
                storeToWrite.insert(Store_type::value_type(i, GeoNode(i+1, i+2)));

                //write to file
                        std::ofstream ofs(fileName);
                        boost::archive::binary_oarchive oa(ofs);
                        oa << const_cast<const Store_type&> (storeToWrite);
                //read from File
                        std::ifstream ifs(fileName);
                        boost::archive::binary_iarchive ia(ifs);
                        ia >> storeThatsRead;

        catch (std::exception e)
        return 0;

An unknown exception is thrown when more than 24 elements are added. Tried
to debug but right now can't make much sense.

Any help is appreciated


View this message in context:
Sent from the Boost - Users mailing list archive at

Boost-users list run by williamkempf at, kalb at, bjorn.karlsson at, gregod at, wekempf at