#include <cstdio>
#include <cstdlib>
#include <vector>
#include <map>
#include <boost/foreach.hpp>
#include <boost/progress.hpp>
#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/binding_of.hpp>
#include <boost/type_erasure/operators.hpp>
#include <boost/fusion/container/map.hpp>
#include <boost/fusion/include/at_key.hpp>

namespace te = boost::type_erasure;
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;

template<class Sequence, class Key, class Reference>
struct at_key
{
    static Reference apply(Sequence& sequence)
    {
        return fusion::at_key<Key>(sequence);
    }
};

template<class Properties, class Reference = mpl::false_>
struct any_map
{
    typedef mpl::vector<
        te::relaxed_match,
        te::copy_constructible<>,
        typename mpl::transform<
            Properties,
            at_key<
                te::_self,
                mpl::first<mpl::_1>,
                mpl::second<mpl::_1>
            >
        >::type
    > concepts;

    typedef te::any<
        concepts,
        typename mpl::if_<Reference, te::_self&, te::_self>::type 
    > type;
};

struct key1 {}; // body needs to be defined for Boost.TypeErasure
struct key2 {};

typedef boost::fusion::map<
    boost::fusion::pair<key1, int>,
    boost::fusion::pair<key2, double>
> map2;

typedef any_map<
    mpl::vector<
        mpl::pair<key1, int&>,
        mpl::pair<key2, double&>
    >
>::type any_map2;

typedef any_map<
    mpl::vector<
        mpl::pair<key1, int&>
    >
>::type any_map1;

typedef any_map<mpl::vector<mpl::pair<key1, int&>>>::concepts any_map1_concepts;

typedef any_map<
    mpl::vector<
        mpl::pair<key1, int&>
    >,
    mpl::true_
>::type any_map1_ref;

struct type_info_cmp
{
    bool operator()(const std::type_info* t1, const std::type_info* t2) const
    {
        return t1->before(*t2) != 0;
    }
};

typedef std::map<const std::type_info*, te::binding<any_map1_concepts>, type_info_cmp> binding_map;
typedef std::map<const std::type_info*, te::binding<any_map1_concepts>> binding_map_ptr_cmp;

int main()
{
    const int N = 1000000;
    const int repeats = 100;

    std::vector<any_map2> any_map2_vec(N);
    for(int i = 0; i < N; ++i) {
        map2 a;
        fusion::at_key<key1>(a) = std::rand() % 100;
        any_map2_vec[i] = a;
    }

    {
        boost::progress_timer t;
        int sum = 0;
        for(int i = 0; i < repeats; ++i) {
            BOOST_FOREACH(auto& x, any_map2_vec) {
                sum += te::call(at_key<te::_self, key1, int&>(), x);
            }
        }
        std::cout << "any_map2: " << sum << std::endl;
    }

    {
        boost::progress_timer t;
        int sum = 0;
        for(int i = 0; i < repeats; ++i) {
            BOOST_FOREACH(auto& x, any_map2_vec) {
                any_map1 y(x);
                sum += te::call(at_key<te::_self, key1, int&>(), y);
            }
        }
        std::cout << "any_map1_ref: " << sum << std::endl;
    }

    {
        boost::progress_timer t;
        int sum = 0;
        for(int i = 0; i < repeats; ++i) {
            mpl::map<mpl::pair<te::_self, te::_self>> placeholder_map;
            te::binding<any_map1_concepts> binding(te::binding_of(any_map2_vec[0]), placeholder_map);
            BOOST_FOREACH(auto& x, any_map2_vec) {
                any_map1_ref y(x, binding);
                sum += te::call(at_key<te::_self, key1, int&>(), y);
            }
        }
        std::cout << "any_map1_ref (single binding): " << sum << std::endl;
    }

    {
        boost::progress_timer t;
        int sum = 0;
        for(int i = 0; i < repeats; ++i) {
            mpl::map<mpl::pair<te::_self, te::_self>> placeholder_map;
            binding_map bindings;
            bindings[&te::typeid_of(any_map2_vec[0])] = te::binding<any_map1_concepts>(te::binding_of(any_map2_vec[0]), placeholder_map);
            BOOST_FOREACH(auto& x, any_map2_vec) {
                // real code would need to check if the binding is already cached and create it if not
                any_map1_ref y(x, bindings[&te::typeid_of(x)]);
                sum += te::call(at_key<te::_self, key1, int&>(), y);
            }
        }
        std::cout << "any_map1_ref (correct map lookup): " << sum << std::endl;
    }

    {
        boost::progress_timer t;
        int sum = 0;
        for(int i = 0; i < repeats; ++i) {
            mpl::map<mpl::pair<te::_self, te::_self>> placeholder_map;
            binding_map_ptr_cmp bindings;
            bindings[&te::typeid_of(any_map2_vec[0])] = te::binding<any_map1_concepts>(te::binding_of(any_map2_vec[0]), placeholder_map);
            BOOST_FOREACH(auto& x, any_map2_vec) {
                // real code would need to check if the binding is already cached and create it if not
                any_map1_ref y(x, bindings[&te::typeid_of(x)]);
                sum += te::call(at_key<te::_self, key1, int&>(), y);
            }
        }
        std::cout << "any_map1_ref (fast map lookup): " << sum << std::endl;
    }

    return 0;
}