Reflang - Modern C++ reflection using libclang
TL;DR
Reflang is a reflection library & tool for modern C++.
The tool parses your C++ code using libclang, then generates human-readable code around it to enable reflection.
The library is extremely lightweight, containing utility interfaces, classes & functions.
Reflang's library has no dependencies other than C++14 with STL. Reflang's tool's only other dependency is libclang (which is not required after code generation).
More details
Functions
Suppose you have the following function:
bool Func(int a, float b);With Reflang you could do:
// Note: no need to include header of Func().
std::vector<IFunction*> functions = reflang::registry::GetFunctionByName("Func");
IFunction* f = functions[0];
Object ret = (*f)(1234, 5678.0f);
if (ret.GetT<bool>())
{
// ...
}Classes
Suppose you have the following class:
class MyClass
{
public:
int field = 0;
static int static_field;
void method();
static void static_method();
};With Reflang you could do:
reflang::Class<MyClass> metadata;
MyClass c;
// Modify / use c's 'field'.
reflang::Reference ref = metadata.GetField(c, "field");
ref.GetT<int>() = 10;
// Modify / use 'static_field'.
ref = metadata.GetStaticField("static_field")
ref.GetT<int>() = 10;
// Execute 'method()'.
auto methods = metadata.GetMethod("method");
(*methods[0])(c);
// Execute 'static_method()'.
auto methods = metadata.GetStaticMethod("static_method");
(*methods[0])();Or even without #includeing MyClass:
// Note: no need to include header of MyClass.
IClass* metadata = reflang::registry::GetClassByName("MyClass");
// Assign 10 to MyClass::static_field.
metadata->GetStaticField("static_field").GetT<int>() = 10;
// Invoke MyClass::static_method().
auto static_methods = metadata->GetStaticMethod("static_method");
(*static_methods[0])();
reflang::Reference c = // get Reference wrapping a MyClass from somewhere.
// Assign 10 to c.field.
metadata->GetField(c, "field").GetT<int>() = 10;
// Invoke c.method().
auto methods = metadata->GetMethod("method");
(*methods[0])(c);Enums
Suppose you have the following enum:
enum class MyEnum
{
Value1 = 4,
Value2,
Value3,
Value4 = Value3,
Value5 = 0,
Value6 = 12
};With Reflang you could do:
for (auto it : reflang::Enum<MyEnum>::Iterate())
{
// Do something with MyEnum values...
}
std::string string_value = reflang::Enum<MyEnum>::Translate(MyEnum::Value2);
// string_value == "Value2".
MyEnum e
if (reflang::Enum<MyEnum>::TryTranslate(string_value, e))
{
// e == MyEnum::Value2.
}Or even without #includeing MyEnum:
// Note: no need to include header of MyEnum.
IEnum* e = reglang::registry::GetEnumByName("MyEnum");
// Iterate over {"Value1", "Value2", "Value3", "Value5", "Value6"}.
for (const auto& s : e->GetStringValues())
{
// ...
}
// Iterate over {4, 5, 6, 0, 12}.
for (const auto& s : e->GetStringValues())
{
// ...
}How it works
Reflang is made of 2 components:
- Code generator, which uses libclang to parse your C++ code and generate reflection information. You can easily integrate this tool in your build process;
- Support library, which allows generic and abstract coding ("find class by name", "invoke function by name", etc).
Reflang understands your code exactly like clang does, so which results in accurate parsing of your code.
End-to-end Examples
Check out the tests/ directory, which shows pretty much all features supported by Reflang.
Each test has 4 files:
X.src.hpp-- source code which will be used for reflection;X.gen.hpp-- generated reflection code declarations forX.src.hpp;X.gen.cpp-- generated reflection code definitions forX.src.hpp;X.test.cpp-- test code which tests the above.
Using
This section is incomplete. Please check later for more elaborated documentation.
Rough instructions:
- Clone the repository;
- Build it using CMake;
- A new executable, reflang is now available - use it to generate code;
- Link your program with the generated code and with libreflang, which has been built by CMake as well;
- Profit.
Examples of running the tool:
# print help
$ ./reflang
# generate code for test.hpp, write both hpp and cpp to stdout
$ ./reflang test.hpp
# specify output files
$ ./reflang --out-cpp test.reflang.cpp --out-hpp test.reflang.hpp test.hpp
# only list classes, functions, etc available for generation
$ ./reflang --list-only true test.hpp
# only generate code for classes, functions, etc not in std::
$ ./reflang --exclude "std::.*" test.hpp
# only generate code for classes, functions, etc beginning with My
$ ./reflang --include "My.*" test.hpp
# pass flags supported by libclang
$ ./reflang test.hpp -- -std=c++14 -DSOMETHING -I./include/Supported Features & Limitations
| ย | Feature |
|---|---|
| โ | Supported: Invoking global / namespace functions |
| โ | Supported: Function overloads |
| โ | Supported: Iterating classes' fields |
| โ | Supported: Iterating classes' static fields |
| โ | Supported: Iterating classes' methods |
| โ | Supported: Iterating classes' static methods |
| โ | Supported: Getting a class field / method / statics by name |
| โ | Supported: Iterating enum values |
| โ | Supported: Get vector of enum values |
| โ | Supported: Get vector of enum string names |
| โ | Supported: Converting enum <-> string |
| โ | Supported: Use class / function / enum without #include (through registry) |
| Soon: Get function's / method's argument names & types | |
| Soon: Get function's / method's return type | |
| Soon: Overloaded class methods | |
| Soon: Construct classes through reflection | |
| Soon: Find types by regex | |
| Soon: Respect functions / methods default values | |
| Soon: Support for operators | |
| โ | Not supported: template classes / functions |
| โ | Not supported: Functions taking non-const reference arguments (yet?) |
| โ | Not supported: Functions taking rvalue references arguments |
| โ | Not supported: Private methods / fields |
| โ | Not supported: Anything in anonymous namespace |
Bugs, pull requests, feedback
Please check this section later.
Kind Words & Donations
Please check this section later.