Question

I’m wrapping the Windows API, and I wish to make error checking easy to use, and helpful. Currently, I have a global error object, with a function set to handle a new error. The set function takes four arguments: bool Error::set (const int code, const char * file, const char * const function, const int line); The function uses the file, function, and line arguments to display them in a nicely formatted message.

To ease the setting of errors, there is a macro #define setError() error.set (GetLastError(), __FILE__, __FUNCTION__, __LINE__); This way I’m able to use setError() at any time to respond to an error that an API function has set by adding it after I call that API function.

Unfortunately, this causes the code to look something like this:

SomeAPIFunction();
setError();
AnotherAPIFunction();
setError();

There is also a problem with constructors:

MyClass:MyClass()
    : a (SomeAPIFunction), b (AnotherAPIFunction)
{
    setError(); //what if both functions set an error?
}

As you can see, by using member initializer syntax, I’m actually limiting myself.

One way to fix this would be to wrap every API function:

int someAPIFunction()
{
    int ret = SomeAPIFunction();
    setError();
    return ret;
}

The function portion of the error message would tell me which function originated the error. Of course, that has to be the worst possible way of dealing with this.

The solution, it seems, is to use variadic templates. The problem is, I have no idea what I’m supposed to be doing to get them working for this. I’d imagine the final code looks something like one of the following:

wrap<int, SomeAPIFunction (5)>();
wrap<int, SomeAPIFunction, 5>();
wrap<int, SomeAPIFunction> (5);

I’ve read things on beginning variadic templates, but they’ve all left me clueless of how to set up something like this. Could anyone point me in the right direction?

I found the following on a similar question:

#include <iostream>

template<void f(void)>
struct Wrap {
   void operator()() const {
      std::cout << "Pre call hook" << std::endl;
      f();
   }
};

namespace {
   void test_func() {
      std::cout << "Real function" << std::endl;
   }
}

const Wrap<&test_func> wrapped_test_func = {};

int main() {
   wrapped_test_func();
   return 0;
}

The respondent noted that variadic templates would be a necessity to make this generic enough. It’s a start, but I’m lost and grateful of any help on the matter.

Answer 1

I think you’ll be able to make it work with this syntax:

wrap(&SomeAPIFunction, arg1, arg2);

The key is to let the compiler use type deduction to determine the template type parameters, since they get pretty messy in a hurry.

The code should look something like:

template<typename TRet, typename... TArgs>
TRet wrap( TRet(WINAPI *api)(TArgs...), TArgs... args )
{
    return api(args...);
}

Naturally, you’ll want to use a macro to hide the address-of-function operator, use stringizing to store the function name, and store the filename and line number also, passing all of that to the actual variadic function. You’ll need variadic macros for that. In fact, could you do all of this just with variadic macros and no templates?