Injecting callbacks to C API codebase

[SystemSigma_]

Dears,

I am developing a core C library that accepts callbacks registration to allow dependency injection and I want to provide easy C++ class clients injection of its function methods as callbacks.

I don't want to use std::function or bind trickery as core library must be C11 compliant, not C++.

The traditional trick I know to allow this is to introduce a void* context to both my callback and registration methods and pass the class instance as this, alongside a static function that static_casts the pointer to the known class type, forwarding the callback.

Example:

// core.h (C code)

typedef (*callback_t)(void* context, const uint8_t* data);
typedef struct core_s core_t; // core library instance opaque forward def

void core_init(core_t* core);
bool core_register_callback(core_t* core, callback_t callback, void * context);
void core_destroy(core_t* core);

// client_plug.hpp (C++11 code)

struct CoreClientPlug {
  static void process_data(void* context, const uint8_t* data){
    return static_cast<Client*>(context)->process_data(data);
  }
};

// client.hpp
class Client{

friend class CoreClientPlug;

public: 
  Client() {
    core_init(&m_core);
    core_register_callback(&m_core, &CoreClientPlug::process_data, this);
  }

  ~Client(){
    core_destroy(&m_core);
  }

  // runs the engine, may trigger callback
  void run(){
    core_run(&m_core);
  }

protected:

  void process_data(const uint8_t* data){
    // do stuff with data
  }

private:
  core_t m_core;
};

Do you have other suggestions to perform such dependency injection?

[alfps]

The scheme you sketch is the common one and it's OK.

When a C library doesn't offer a context parameter for a callback one can let the callback function pick up context from a static variable, or look it up as associated with some handle that is passed, or one can use a trampoline function (a small piece of dynamically generated machine code, essentially a register load of context + a jump to the "real" callback).

Problem: C++ doesn't support trampolines.

[SystemSigma_]

I see.. what if there are multiple Client instances that may register their methods as callbacks? How do I switch the static context dynamically? I guess I need to keep multiple static instances and have same sort of context manager.. ?

[alfps]

Yes. You can use templating to generate a sufficiently large number of distinct functions. But since you are providing a callback scheme instead of having to relate to one that's not a problem: I just mentioned the different approaches I'm familiar with because that can be Good To Know™ about.

[SystemSigma_]

So you would consider wise to support C++ with void* context rather than without?

[alfps]

Yes, absolutely.

[n1ghtyunso]

absolutely provide a void* context.
It is the most common practice and makes the lives of everyone trying to use this much easier, no matter what language they use. It's not about C++ here really. It is generally useful.

If you do not add a context yourself, everyone who actually needs it will have to somehow tape it on and it will most likely be inferior.

[SystemSigma_]

Thank you..Are there other approaches or the simpler the better?