#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <iostream>

template<int...> struct int_tuple {};

// make indexes impl is a helper for make indexes
template<int I, typename IntTuple, typename... Types>
struct make_indexes_impl;

template<int I, int... Indexes, typename T, typename... Types>
struct make_indexes_impl<I, int_tuple<Indexes...>, T, Types...>
{
    typedef typename make_indexes_impl<I + 1, int_tuple<Indexes..., I>, Types...>::type type;
};

template<int I, int... Indexes>
struct make_indexes_impl<I, int_tuple<Indexes...> >
{
    typedef int_tuple<Indexes...> type;
};

template<typename... Types>
struct make_indexes: make_indexes_impl<0, int_tuple<>, Types...> { };

template< class T, class... Args >
struct cb_ { typedef void (T::*type)(Args...); };

template< class T, class... Args, int... Indexes >
boost::function< void(Args...) > make_func_helper( typename cb_<T, Args...>::type cb, T* that, int_tuple< Indexes... > )
{
    return boost::bind( cb, that, boost::arg<Indexes + 1>()... );
}

template< class T, class... Args >
struct func
{
    boost::function< void(Args...) > f;

    func( typename cb_<T, Args...>::type cb, T* that)
    {
        f = make_func_helper( cb, that, typename make_indexes<Args...>::type() );
    }

    void call(Args...)
    {
        boost::function< void() > bound_fn = boost::bind(f, Args...);
        bound_fn(); // in effect the bound_fn will be stored in a queue for later envocation by a different thread
    }
};

struct X
{
    void f(int a, int b, double c)
    {
        std::cout << "a=" << a << " b=" << b << ", c=" << c << std::endl;
    }
};

int main()
{
    X x;
    func<X, int, int, double> fn( &X::f, &x );

    fn.f( 1, 2, 1.2 );

    boost::function< void() > bound_fn = boost::bind(fn.f, 3, 4, 9.8);
    bound_fn();

    fn.call(7, 3, 19.8);
}