#include <tuple>
#include <utility>

namespace detail
{
    template<int... Is>
    struct seq { };
    
    template<int N, int... Is>
    struct gen_seq : gen_seq<N - 1, N - 1, Is...> { };
    
    template<int... Is>
    struct gen_seq<0, Is...> : seq<Is...> { };
    
    template<typename F, typename... Ts, int... Is>
    void call_with_tuple(F&& f, std::tuple<Ts...> const& t, seq<Is...>)
    {
        (std::forward<F>(f))(std::get<Is>(t)...);
    }
}

template<typename F, typename... Ts>
void call_with_tuple(F&& f, std::tuple<Ts...> const& t)
{
    detail::call_with_tuple(std::forward<F>(f), t, detail::gen_seq<sizeof...(Ts)>());
}

#include <iostream>
#include <functional>

template< typename ... Args >
class Message {
public:
    Message( Args&& ... args ) {
        mArgs = std::make_tuple( args ...  );
    }

    std::tuple< Args ... > mArgs;
    typedef std::function< void ( Args ... ) > HandlerType;

    void Consume( HandlerType handler ) {
        call_with_tuple(handler, mArgs);
    }
};


int main()
{
    // Testing code
    Message<int, int> msg(1, 2);

    msg.Consume( [] ( int i, int j ) {
        std::cout << i << ',' << j << '\n';
    });
}