#include <boost/mpl/map.hpp>
#include <boost/mpl/pair.hpp>
#include <boost/mpl/erase_key.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/deref.hpp>
#include <iostream>


namespace mpl = boost::mpl;

//=============================================================================
//Template meta function that joins two maps (normally in a header file)
template< class, class MapL, class MapR >
struct join_maps_imp;

//=============================================================================
template< class MapL, class MapR >
struct join_maps
{
  typedef typename join_maps_imp< typename mpl::less< typename mpl::size<MapL>::type
                                                    , typename mpl::size<MapR>::type >::type
                                , MapL
                                , MapR
                                >::type type;
};

//=============================================================================
//MapR is smaller than MapL, so add R to L
template< class MapL, class MapR >
struct join_maps_imp<mpl::false_, MapL, MapR>
{
  typedef typename join_maps_imp<mpl::true_, MapR, MapL>::type type;
};


//=============================================================================
namespace join_maps_detail
{
  //The loop
  template<bool done, class iter, class end_iter, class OldMap>
  struct next_elem
  {
    typedef typename mpl::deref< iter >::type MapElem;
    typedef typename mpl::insert< OldMap, MapElem >::type NewMap;
    typedef typename mpl::next<iter>::type next_iter;
    typedef typename next_elem<boost::is_same<next_iter, end_iter>::value
                              , next_iter
                              , end_iter
                              , NewMap >::type type;
  };

  //Loop termination
  template<class iter, class end_iter, class NewMap>
  struct next_elem<true, iter, end_iter, NewMap >
  {
    typedef NewMap type;
  };

};

//=============================================================================
//MapL is smaller than MapR, so add L to R
template< class MapL, class MapR >
struct join_maps_imp<mpl::true_, MapL, MapR>
{

  //Initialize the loop
  typedef typename mpl::begin<MapL>::type iter;
  typedef typename mpl::end<MapL>::type end_iter;

  typedef typename join_maps_detail::next_elem<false
                                              , iter
                                              , end_iter
                                              , MapR>::type type;

};

//=============================================================================
template<int i>
struct print {};

//=============================================================================
template<int i>
std::ostream& operator<<(std::ostream& out, const print<i>&)
{
  out << i;
  return out;
}

//=============================================================================
 struct map_printer
 {    
    template <class T>
    inline void operator() (T) const
    {
      std::cout << " " << typename T::second();
    }
  };

/*###################################################################*/
int main(int argc, const char* argv[])
{
  //Create a couple of maps using insert (this replicates the actual code)
  typedef mpl::insert<mpl::map<>, mpl::pair< mpl::int_<0>, print<0> > >::type map0;
  typedef mpl::insert<map0      , mpl::pair< mpl::int_<1>, print<1> > >::type map1;
  typedef mpl::insert<map1      , mpl::pair< mpl::int_<2>, print<2> > >::type map2;

  typedef mpl::insert<mpl::map<>, mpl::pair< mpl::int_<3>, print<3> > >::type map3;
  typedef mpl::insert<map3      , mpl::pair< mpl::int_<4>, print<4> > >::type map4;
  typedef mpl::insert<map4      , mpl::pair< mpl::int_<5>, print<5> > >::type map5;

  //Erease a couple of keys
  typedef mpl::erase_key<map2, mpl::int_<1> >::type map_erase1;
  typedef mpl::erase_key<map5, mpl::int_<4> >::type map_erase2;

  //Join the maps into a single map
  typedef join_maps< map2      , map_erase2 >::type join1;
  typedef join_maps< map_erase1, map5       >::type join2;
  typedef join_maps< map_erase1, map_erase2 >::type join3;

  //Print out the resuling maps
  std::cout << std::endl;
  boost::mpl::for_each< join1 >(map_printer()); //Works

  std::cout << std::endl;
  boost::mpl::for_each< join2 >(map_printer()); //Works

  std::cout << std::endl;
  boost::mpl::for_each< join3 >(map_printer()); //MSVC 9 error (works with CYGWIN GCC 4.3.2 )

  std::cout << std::endl;

}