c++c++14libsigc++

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

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.

Solution

  • 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 :

    comments are very welcome