C++ Automatically Exposing Class Members to Multiple APIs - c++

Question

Short:
There are many clever libraries out there that allow you to expose a class' members for various purposes, such as serialisation, exposure to a lua environment, etc. The problem is that for each clever solution you have to register a class' stuff for each api, which results in a lot of work duplication and boilerplate.
What is a way that I can register a class and its members and methods ONCE with some kind of flags attached and get various autogenerated methods
Long:
Lets say I have a class:
class C {
public:
int i; // Some int
vec3 v; // Some non-POD value
int function(int foo, char bar) // Some function
int hidden; // Some internal stuff I don't want exposed
}
What I'd like to do is be able to mark various members and methods at declaration time to have them be put in the various boilerplate automatically:
So declaration might look like:
class C {
public:
LUAREG JSON BINSER int i; // Marks member "i" to be exposed to the lua enviroment,
// JSON serialisable, binary serialisable
JSON vec3 v; // Only exposed to JSON function
LUAREG void someFunction() {} // Marks this method to be exposed to the lua enviroment
}
Or perhaps writing one registration function that does all the declarations:
void C::register_class() {
registrator::register_class<C>("C")
.addData("i", &i, FLAG_LUA | FLAG_JSON | FLAG_BINARY_SERIALISABLE)
.addFunction("someFunction", &someFunction, FLAG_LUA)
.end_class()
}
(I've seen this pattern some times - does this have a name?)
I want to be able to automatically generate various boilerplate functions for said class. For example:
/// Adds all fields with FLAG_JSON to a "json" object to be later serialised
void toJson(const C & c, json & j) {
toJson(c.i, "i", j);
toJson(c.v, "v", j);
}
/// Binary seralises all members with flag FLAG_BINARY_SERIALISABLE and stores the result in s
void serialise(const C & c, string & s) {
serialise(c.i, s);
serialise(c.v, s);
}
/// Registers all stuff with flag FLAG_LUA to some lua environment
void register_lua(lua_State * const L) {
luaReg_FetchContext(L)::addClass("C")
.addData("x", &C::x).comment("Some int") // generates documentation of "int x : Some int"
.addData("v", &C::v).comment("Some vector")
.addFunction("function", &C::function).comment("some function") // generates: "int function(int, char) : some function"
.endClass()
}
/// Register to some *other* lua environment (such as a read only context for rendering)
void register_lua_readonly(lua_State * const L2) {
luaReg_FetchContext(L)::addClass("C")
.addData("x", &C::x, false).comment("Some int")
.endClass()
}
/// Generates some user readable breakdown of all members
string dump() {
...
}
Now you can see with many classes this will become very tedious, bloaty and error prone to do manually
What is the best way to approach this? I am tempted to use a macro to spit out the functions, but have no idea how to approach the registration stage. Cheers!

Answer 1

I have a solution for this - I rolled my own reflection library - https://github.com/SnapperTT/STTR
class C {
public:
int i;
double d;
int func(int z) const {
return z;
}
static int static_var;
static int static_func() { return 5; }
};
int C::static_var = 7;
struct D : public C {
int di;
};
int main(int argc, char ** argv) {
// Registration
sttr::RegNamespace mNamespace("testns");
mNamespace.beginClass<C>("C")
.regField(&C::i, "i")
.regField(&C::d, "d")
.setUserFlags(0x00F00BAA) // Sets the user flags for the last added item
.setUserString("You can use this for whatever")
.setUserData((void *) &someStruct)
.regField(&C::func, "func")
.regField(&C::static_var, "static_var")
.regField(&C::static_func, "static_func")
.endClass()
.findClass("C").beginClass<D>("D") // Class inherritance. Also you can just beginClass<D>("D") inside C
.regField(&D::di, "di")
.endClass();
}
The key to this solution is that I can attach flags to registered members (so LUA could be 1 << 0, JSON could be 1 << 1, etc.
Automatic json serialisation and lua registration is done via a visitor. The visitor checks if the members have the relevent flag and either does its thing or skips onto the next member.
I have also attempted to use RTTR: https://github.com/rttrorg/rttr - its a nice, if albeit bulky library. I rolled my own library because I didn't like the visitor interface and the voluminous template error messages.
Finally automatic documentation is done by running a script that does a bunch of regex find-and-substitutes to pick out cases of typename Foo; /// Some documentation and create a static const char * const docv_Foo = "Some documentation"; and registers it. This does add an intermediate step to compilation but its not at all bad.