wrapping a C-function with a static callback parameter to a C++-function which accepts a private member as callback

Question

I want to wrap this C-function,

int sqlite3_exec(
  sqlite3*,                                  /* An open database */
  const char *sql,                           /* SQL to be evaluated */
  int (*callback)(void*,int,char**,char**),  /* Callback function */
  void *,                                    /* 1st argument to callback */
  char **errmsg                              /* Error msg written here */
);

in a C++ function like,

namespace
IronMaiden
{
  int
  BookOfSouls::MyWrapper( DB* db
  , std::string& sql
  , ?? callback function ?? int (*callback)(void*,int,char**,char**) ?? )
  {
    .
    .
    .
    sqlite3_exec( db->get(), sql.c_str(), ?? callback ??, nullptr, nullptr);
    .
    .
    .
  }
}

I can pass any static function to sqlite3_exec(), but I want to pass a private member function from a BookOfSouls object as the callback function and I want to access the private data of the object from that function.

Answer 1

ok, so after some tests and failures I got a way to achieve EXACTLY what I want to do.

My solution isn't straightforward... my fears come true...

After spending several hours to crawl on SO and internet ( like in a dark, cold and creepy dungeon, with my light torch and some Angelscourge's music ) I conclude there is NO such thing as a straightforward way!

         /*...I can't blame a C lib to don't support some C++ feature...*/

so, I needed to found another strategy... so I heavily used my brain (a.k.a. headbanging)... there popped a solution :

          /* The solution uses `libsigc++` AND a static function. */

The static function is in the namespace of the wrapper. This static function will do one thing, emit a signal. so if I take the same example as in the question,

namespace
IronMaiden
{
  sigc::signal<int,void*,int,char**,char**> signalCB; // `extern` is a friend
  .
  .
  .
  static int 
  callback( void *PersonalUse
          , int argc
          , char **argv
          , char **azColName )
  {
    return IronMaiden::signalCB.emit( PersonalUse, argc, argv, azColName);

  }
  .
  .
  .
  int
  BookOfSouls::MyWrapper( DB* db
                        , std::string& sql
                        , const sigc::slot<int,void*,int,char**,char**>& slotCB )
  {
    .
    .
    .
    sigc::connection signalConnection = IronMaiden::signalCB.connect( slotCB );
    sqlite3_exec( db->get(), sql.c_str(), callback, nullptr, nullptr);
    signalConnection.disconnect();
    .
    .
    .
  }
}

To connect a (private member) function, let say YearOfTheGoat::ImTheCallbackFunction(), from a YearOfTheGoat object,

YearOfTheGoat::ImSomeFunctionFromWhereIWantToUseMyWrapper()
{
  IronMaiden::MyWrapper( DBobj, transaction
                 , sigc::mem_fun(*this, &YearOfTheGoat::ImTheCallbackFunction) );
}

so now everytime that sqlite3_exec() calls callback(), that one will emit the signal, then calling ImTheCallbackFunction()

some important notes :

• in this example, the parameters and the return type of ImTheCallbackFunction() have to be identical to the ones of callback().
• be aware to disconnect or the signal will stay connected.
• I got no issue with that solution so far. But you have to understand I wrote this answer right after I wrote the code in my program. So I'm not gonna claim it's THE BEST solution. But it WORKS!
• note about sqlite3_exec, it seems that the cb function is called only if there is something to returns.
• don't be confused between BookOfSouls and YearOfTheGoat. The first is NON instanciable. The second, I used an object. (N.B. since BookOfSouls is non instanciable, moving callback and sigc::signal inside BookOfSouls isn't a bad idea).

comments are very welcome

Answer 2

The key is the void* argument:

int (*callback)(void*,int,char**,char**),  /* Callback function */
void *,                                    /* 1st argument to callback */

The callback is a free function, but you can provide an arbitrary first argument into. So if you want to pass in a member function, we can take advantage of the fact that a no-capture lambda is convertible to a function pointer (thanks to some sorcery):

template <typename F, int (F::*mem)(int, char**, char**)>
void set_callback(F* f) {
        sqlite3_exec(db->get(), sql.c_str(), 
            +[](void* arg, int i, char** p, char**q){
                return (static_cast<F*>(arg)->*mem)(i, p, q);
            },
            f,
            nullptr, nullptr);
}

Note that the member function has to also be a template argument so that the lambda doesn't have to capture. It'd be simpler if you just required a particular function name, e.g. sqlCallback(), then your callback function would be:

+[](void* arg, int i, char** p, char** q) {
    return static_cast<F*>(arg)->sqlCallback(i, p, q);
}