#include <boost/mpl/fold.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/vector_c.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/fusion/algorithm.hpp>
#include <boost/fusion/container.hpp>
#include <boost/fusion/sequence.hpp>
#include <boost/fusion/functional.hpp>
//#include <boost/fusion/view.hpp>
#include <boost/fusion/view/nview.hpp>
#include <boost/range.hpp>
#include <boost/foreach.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <vector>
#include <iostream>

namespace fusion=boost::fusion;
namespace mpl=boost::mpl;

struct deref_data
{
	template<typename Sig>
	struct result;

	template<typename Self, typename Pair>
	struct result<Self(Pair)>
	{
		typedef typename boost::remove_reference<Pair>::type pair;

		typedef typename
			boost::add_reference<
				typename mpl::eval_if<
					boost::is_const<pair>,
					boost::add_const<typename pair::second_type>,
					mpl::identity<typename pair::second_type>
				>::type
			>::type
		type;
	};

	template<typename Pair>
	typename result<deref_data const&(Pair&)>::type
	operator()(Pair& p)const
	{
		return p.second;
	}

	template<typename Pair>
	typename result<deref_data const&(Pair const&)>::type
	operator()(Pair const& p)const
	{
		return p.second;
	}
};

template<typename Seq, typename Key>
struct distance_to_beg:
	fusion::result_of::distance<
		typename fusion::result_of::begin<Seq>::type,
		typename fusion::result_of::find<Seq,Key>::type
	>
{};

template<typename MasterKey, typename Keys, typename Range, typename F>
F
for_each(Range& range, F f)
{
	typedef typename boost::range_value<Range>::type range_value;
	typedef typename boost::range_reference<Range>::type range_reference;
	typedef
		fusion::nview<
			typename boost::remove_reference<range_reference>::type,
			typename mpl::fold<
				Keys,
				mpl::vector_c<int>,
				mpl::push_back<
					mpl::_1,
					distance_to_beg<range_value,mpl::_2>
				>
			>::type
		>
	reordered;

	BOOST_FOREACH(range_reference v, range)
	{
		fusion::at_key<MasterKey>(v)=
			fusion::invoke(f, fusion::transform(reordered(v),deref_data()));
	}

	return f;
}

int test_f(void*, double)
{
	return 123;
}

int
main()
{
	typedef fusion::map<fusion::pair<double,double>,fusion::pair<int,int>,fusion::pair<void*,void*> > map;
	std::vector<map> v;
	v.push_back(map(0,0,0));

	for_each<int,mpl::vector<void*,double> >(v,test_f);
	std::cout << fusion::at_key<int>(v.front()) << std::endl;
	return fusion::at_key<int>(v.front())!=123;
}