Cylix

//! our function base class, non-templated.
//! it does really nothing, except helping us to store functions in the same container
class function_base {
public:
  virtual ~function_base(void) = default;
};

//! our function class, templated on return and parameters types
template <typename ReturnType, typename... Params>
class function;

Cylix

template <typename T>
class reflectable : reflectable_base {
public:
  //! constructor of a reflectable class where we can process the registration
  //! note the presence of variadic template to accept any number of member functions
  template <typename... Fcts>
  reflectable(const std::string& class_name, Fcts... fcts) : name(class_name) {
    reflection_manager::get_instance().register_reflectable(*this);
  }

Cylix

class reflection_manager {
public:
  ~reflection_manager(void) = default;
  reflection_manager(const reflection_manager&) = delete;
  refleection_manager& operator=(const reflection_manager&) = delete;

  static reflection_manager& get_instance(void) {
    static reflection_manager instance;
    return instance;
  }

Cylix

class reflectable_base {
public:
  virtual ~reflectable_base(void) = default;

  virtual const std::string& get_name(void) const = 0;
};

template <typename T>
class reflectable : reflectable_base {
public:

Cylix

template <typename T>
class reflectable {
public:
  //! constructor of a reflectable class where we can process the registration
  reflectable(const std::string& class_name) : name(class_name) {
    reflection_manager::get_instance().register_reflectable(*this);
  }

  //! function to get reflectable name
  const std::string& get_name(void) const {

Cylix

class reflection_manager {
public:
  ~reflection_manager(void) = default;
  reflection_manager(const reflection_manager&) = delete;
  reflection_manager& operator=(const reflection_manager&) = delete;

  static reflection_manager& get_instance(void) {
    static reflection_manager instance;
    return instance;
  }

Cylix

class reflectable {
public:
  //! constructor of a reflectable class where we can process the registration
  reflectable(/* ... */) {
    //! registration of a class or member function here
  }
};

static reflectable register_some_class;

Cylix

#include <iostream>

class A {
public:
  A(void) { std::cout << "A::A()" << std::endl; }
};

static A a;

int main(void) {

Cylix

int main(void) {
  REGISTER_CLASS(SomeClass)
  REGISTER_MEMBER_FUNCTION(SomeClass::some_function)
  // ...
}

Cylix

#include <dlfcn.h>
#include <iostream>

extern "C" {

  void display_nb(int nb) {
    std::cout << nb << std::endl;
  }

}