Question

I have an http server that has a request handler like that :

bool handleRequest(const RequestObject& request, ResponseRequest& response);

I’m trying to write a wrapper that would provide an API like that :

addRouteHandler(GET, "/foo/bar", handler);

With handler able to be either :

1. a function : bool handleFooBarRequest(const RequestObject& request, ResponseRequest& response);
2. a method on an existing object : FooResourceInstance + bool FooResource::handleFooBarRequest(const RequestObject& request, ResponseRequest& response);
3. a static method of an object : static bool FooResource::handleFooBarRequest(const RequestObject& request, ResponseRequest& response);

I insist : C++03 (gcc 4.1.2) and no Boost (the reason is NOT the point)

So far the techniques I have found either use Boost, C++11 or third-party code (http://www.codeproject.com/Articles/136799/Lightweight-Generic-C-Callbacks-or-Yet-Another-Del)

Answer 1

Use an interface and a derived template class. This technique is called “type erasure”.

class CallbackBase
{
public:
    virtual ~CallbackBase() = 0;
    virtual bool exec(const RequestObject& request, ResponseRequest& response) = 0;
};

template <typename F>
class CallbackImpl : public CallbackBase
{
public:
    CallbackImpl(F f) : f_(f) {}
    virtual bool exec(const RequestObject& request, ResponseRequest& response) {
        return f_(request, response);
    }
private:
    F f_;
};

template <typename F>
void CreateCallback(F f, std::auto_ptr<CallbackBase>& r) {
    r.reset(new CallbackImpl<F>(f));
}

// examples
std::auto_ptr<CallbackBase> my_callback;

CreateCallback(GlobalFooBarRequest, my_callback);
CreateCallback(&FooResource::staticFooBarRequest, my_callback);
// for member function, use std::mem_fun and std::bind1st
...

my_callback->exec(request, response);

You might want to use a shared_ptr or similar instead of auto_ptr, all depends on how you want to store these objects.

Edit:
you can write your own member function wrapper/closure/function object. Code would looks something like the following (I haven’t tried compiling it so there could be some errors):

template <typename T>
class RequestWrapper
{
    typedef bool (T::*F)(const RequestObject&, ResponseRequest&);
    T* obj_;
    F f_;
public:
    RequestWrapper(T* obj, F f)
    : obj_(obj)
    , f_(f)
    {}

    bool operator()(const RequestObject& request, ResponseRequest& response) const {
        return (obj_->*f_)(request, response);
    }
};

template <typename T, typename F>
RequestWrapper<T> BindRequestMfn(T* obj, F mfn)
{
    return RequestWrapper<T>(obj, mfn);
}


CreateCallback(BindRequestMfn(foo, &FooResource::fooBarRequest), my_callback);