Manual registration

Register your properties, methods or constructors in your source files.

Adjusting the class interface is only necessary when using inheritance.

#include <rttr/registration>
using namespace rttr;

struct MyStruct { MyStruct() {}; void func(double) {}; int data; };

RTTR_REGISTRATION
{
    registration::class_<MyStruct>("MyStruct")
         .constructor<>()
         .property("data", &MyStruct::data)
         .method("func", &MyStruct::func);
}

Iterate over members

With the type object you can query your previously registered members.

Of course including all previously registered base classes.

type t = type::get<MyStruct>();
for (auto& prop : t.get_properties())
    std::cout << "name: " << prop.get_name() << std::endl;

for (auto& meth : t.get_methods())
    std::cout << "name: " << meth.get_name() << std::endl;

Constructing types

You don't have to include the actual class declaration to work with a type.

Via the type object or constructor object you can create instances of your type, wrapped inside a variant object.

type t = type::get_by_name("MyStruct");
variant var = t.create();    // will invoke the previously registered ctor

constructor ctor = t.get_constructor();  // 2nd way with the constructor class
var = ctor.invoke();
std::cout << var.get_type().get_name();  // prints 'MyStruct'

Set/get properties

It is pretty simple to set or get a property. Take a look at the following code:

MyStruct obj;

property prop = type::get(obj).get_property("data");
prop.set_value(obj, 23);

variant var_prop = prop.get_value(obj);
std::cout << var_prop.to_int(); // prints '23'

Invoke methods

Calling a method is straight forward.

It is also possible to use the variant object to invoke a method.

MyStruct obj;

method meth = type::get(obj).get_method("func");
meth.invoke(obj, 42.0);

variant var = type::get(obj).create();
meth.invoke(var, 42.0);

Features

Following features are supported:

• reflect constructors, methods, data member or enums
• classes; with single-, multiple- and virtual-inheritance
• constructors (arbitrary argument count)

• methods (virtual, abstract, overloaded, arbitrary argument count)
• arrays (incl. raw-arrays; arbitrary dimension count)
• ability to invoke properties and methods of classes from any arbitrary class level
• no header pollution; the reflection information is created in the cpp file to minimize compile time when modifying the data
• working with custom types without the need of having the declaration of the type available at compile time (useful for plugins)
• possibility to add additional metadata to all reflection objects
• possibility to add default arguments to methods or constructors
• adjust registration behaviour through policies
• minimal macro usage
• no additional 3rd party dependencies are needed
• no rtti required; contains a faster and across shared libraries working replacement
• no exceptions (this feature come with cost and is also regularly disabled on consoles)
• no external compiler or tool needed, only standard ISO C++11

View More »

Portability

Tested and compiled with:

• Microsoft Visual Studio 2013, 2015
• GCC 4.8.1
• Clang 3.7

• MinGW 4.8.1

View More »

License

RTTR is released under the terms of the MIT license, so it is free to use in your free or commercial projects.

Development

The repository is hosted under GitHub.