Extends

So, I'm trying to learn template metaprogramming better and I figure this is a good exercise for it.

I'm trying to write code that can callback a function with any number of arguments I like passed to it.

// First function to call
int add( int x, int y ) ;

// Second function to call
double square( double x ) ;

// Third func to call
void go() ;

The callback creation code should look like:

// Write a callback object that
// will be executed after 42ms for "add"
Callback<int, int, int> c1 ;
c1.func = add ;
c1.args.push_back( 2 );  // these are the 2 args
c1.args.push_back( 5 );  // to pass to the "add" function
                         // when it is called

Callback<double, double> c2 ;
c2.func = square ;
c2.args.push_back( 52.2 ) ;

What I'm thinking is, using template metaprogramming I want to be able to declare callbacks like, write a struct like this (please keep in mind this is VERY PSEUDOcode)

<TEMPLATING ACTION <<ANY NUMBER OF TYPES GO HERE>> >
struct Callback
{
    double execTime ; // when to execute
    TYPE1 (*func)( TYPE2 a, TYPE3 b ) ;

    void* argList ;   // a stored list of arguments
                      // to plug in when it is time to call __func__
} ;

So for when called with

Callback<int, int, int> c1 ;

You would automatically get constructed for you by < HARDCORE TEMPLATING ACTION > a struct like

struct Callback
{
    double execTime ; // when to execute
    int (*func)( int a, int b ) ;

    void* argList ;   // this would still be void*,
                      // but I somehow need to remember
                      // the types of the args..
} ;

Any pointers in the right direction to get started on writing this?