Write a bimap to binary file and then read it

I would like to know how to write a bimap which is actually too large( 180 million to 3000 million entries) to a binary file and then read to do some operation. To create a bimap I have the following code, where I created two streams to write and read binary data. I also insert the elements into the bimap.

#include <string>
#include <iostream>
#include <utility>
#include <fstream>
#include <boost/bimap.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <boost/bimap/unordered_multiset_of.hpp>

namespace bimaps = boost::bimaps;
typedef boost::bimap<bimaps::unordered_set_of<unsigned long long int>,
        bimaps::unordered_multiset_of<unsigned long long int > > bimap_reference;
typedef bimap_reference::value_type position;
bimap_reference numbers;

int main()
{
    std::ofstream outfile ("bmap",std::ofstream::binary);
    std::ifstream infile ("bmap",std::ifstream::binary);

    numbers.insert(position(123456, 100000));
    numbers.insert(position(234567, 80000));
    numbers.insert(position(345678, 100000));
    numbers.insert(position(456789, 80000));

    //want to write the file

    //want to read the file


    // So that I can perform the following operation
    using ritr = bimap_reference::right_const_iterator;
    std::pair<ritr, ritr> range = numbers.right.equal_range(80000);
    auto itr = range.first;
    std::cout<<"first: "<<itr->first<<std::endl;
    if(itr != numbers.right.end() && itr->second ==80000){
        for (itr = range.first; itr != range.second; ++itr)
        {
            std::cout<<"numbers:"<<itr->second<<"<->"<<itr->first<<std::endl;
        }
    }
    else {
        std::cout<<"Not found:"<<std::endl;
    }
    return 0;
}

I want to write the bimap, and then read it again to perform some operation. How to do it.

To handle bimap write/read to/from binary file, boost serialization is very helpful. You need to include

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

as header files. Then you need to have file streams for write and read, and use boost::archive::binary_oarchive to write and boost::archive::binary_iarchive to read back. Also make sure you compile the code using -lboost_serialization. The full code is given below.

#include <string>
#include <iostream>
#include <utility>
#include <fstream>
#include <boost/bimap.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <boost/bimap/unordered_multiset_of.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>



namespace bimaps = boost::bimaps;
typedef boost::bimap<bimaps::unordered_set_of<unsigned long long int>,
        bimaps::unordered_multiset_of<unsigned long long int > > bimap_reference;
typedef bimap_reference::value_type position;
bimap_reference numbers;

int main()
{

    // insert elements into bimap and write to a binary file
    {
        numbers.insert(position(123456, 100000));
        numbers.insert(position(234567, 80000));
        numbers.insert(position(345678, 100000));
        numbers.insert(position(456789, 80000));

        std::ofstream ofs("data");
        boost::archive::binary_oarchive oa(ofs);
        oa << const_cast<const bimap_reference&>(numbers);
        const bimap_reference::left_iterator left_iter = numbers.left.find(123456);
        oa << left_iter;
        const bimap_reference::right_iterator right_iter = numbers.right.find(100000);
        oa << right_iter;
    }

    // load the bimap back to memory
    {
        std::ifstream ifs("data", std::ios::binary);
        boost::archive::binary_iarchive ia(ifs);
        ia >> numbers;
        assert( numbers.size() == 4 ); // to throw an error
        bimap_reference::left_iterator left_iter;
        ia >> left_iter;
        assert( left_iter->first == 123456 );
        bimap_reference::right_iterator right_iter;
        ia >> right_iter;
        assert( right_iter->first == 100000 );
    }

    // then perform the following operation
    using ritr = bimap_reference::right_const_iterator;
    std::pair<ritr, ritr> range = numbers.right.equal_range(80000);
    auto itr = range.first;
    std::cout<<"first: "<<itr->first<< " <-> " << itr->second<<std::endl;
    if(itr != numbers.right.end() && itr->first ==80000){
        for (itr = range.first; itr != range.second; ++itr)
        {
            std::cout<<"numbers:"<<itr->second<<"<->"<<itr->first<<std::endl;
        }
    }
    else {
        std::cout<<"Not found:"<<std::endl;
    }
    return 0;
}