From Qt Properties, RTTR and refl-cpp​

C++ reflection libraries answer one question: what fields does this object have, and how do I read and write them by name? Qt answers with Q_PROPERTY and the moc-generated meta-object, RTTR with a run-time registration block, refl-cpp with a compile-time member list.

In JaiScript a property is a member declared with JAI_PROPERTY on a jai::property_owner, and that one declaration serves run-time reflection by name, serialization, script access and, through JAI_OBSERVABLE_PROPERTY and JAI_SIGNAL_PROPERTY, change signals. The trade is scope: no user metadata on a property, no compile-time member list, no property added at run time (What has no counterpart).

The declaration is documented in dynamic_binder, observable values and signals in Signals & Observable Properties, and script-side reflection in the guide's Reflection.

The concept map​

Headers: <jaiscript/properties/macros.hpp> and <jaiscript/properties/property_serialization.hpp> for the declarations, <jaiscript/properties/observable_property.hpp> for observable values, <jaiscript/signals/signal_property.hpp> for JAI_SIGNAL_PROPERTY, and <jaiscript/core/registrar.hpp> to make the class scriptable.

Declaring​

Reading and writing by name​

From script​

A class converted​

A turret with a name, ammunition, a range limited to 0..50, a heat level other systems watch, and a cooldown nobody saves. In Qt:

class Turret : public QObject {
    Q_OBJECT
    Q_PROPERTY(QString name MEMBER m_name)
    Q_PROPERTY(int ammo MEMBER m_ammo)
    Q_PROPERTY(double range MEMBER m_range)
    Q_PROPERTY(int heat READ heat WRITE setHeat NOTIFY heatChanged)
    Q_PROPERTY(double cooldown MEMBER m_cooldown STORED false)
public:
    int heat() const { return m_heat; }
    void setHeat(int heat) {
        if (heat == m_heat) { return; }
        m_heat = heat;
        emit heatChanged(heat);
    }
signals:
    void heatChanged(int heat);
private:
    QString m_name = "north";
    int m_ammo = 10;
    double m_range = 12.5;
    int m_heat = 0;
    double m_cooldown = 0.0;
};

const QMetaObject* meta = turret.metaObject();
for (int i = meta->propertyOffset(); i < meta->propertyCount(); ++i) {
    qDebug() << meta->property(i).name();
}
turret.setProperty("ammo", 3);
QObject::connect(&turret, &Turret::heatChanged, [](int heat) { qDebug() << heat; });

RTTR registers the same members of a plain struct, with the range as metadata; refl-cpp describes them beside the class and walks them in templates:

RTTR_REGISTRATION {
    rttr::registration::class_<Turret>("Turret")
        .constructor<>()
        .property("name", &Turret::name)
        .property("ammo", &Turret::ammo)
        .property("range", &Turret::range)(rttr::metadata("min", 0.0), rttr::metadata("max", 50.0));
}

rttr::type type = rttr::type::get<Turret>();
for (auto& prop : type.get_properties()) {
    std::cout << prop.get_name() << "\n";
}
type.get_property("ammo").set_value(turret, 3);

REFL_AUTO(
    type(Turret),
    field(name),
    field(ammo),
    field(range, Range(0.0f, 50.0f))     // Range: a user attribute deriving refl::attr::usage::field
)

for_each(refl::reflect<Turret>().members, [&](auto member) {
    std::cout << get_display_name(member) << " = " << member(t) << "\n";
});

#include <jaiscript/core/registrar.hpp>
#include <jaiscript/properties/macros.hpp>
#include <jaiscript/properties/property_serialization.hpp>
#include <jaiscript/properties/observable_property.hpp>

class Turret : public jai::property_owner<Turret> {
public:
    JAI_PROPERTY((std::string), name, "north");
    JAI_PROPERTY((int64_t), ammo, 10);
    JAI_PROPERTY((double), range, 12.5);
    JAI_OBSERVABLE_PROPERTY((int64_t), heat, 0);
    JAI_TRANSIENT_PROPERTY((double), cooldown, 0.0);
};

static jai::registrar<Turret, void> turretRegistrar("Turret");

auto turret = std::make_shared<Turret>();
turret->visit_reflected_properties([](const std::string& name, jai::property_base* p) {
    std::cout << name << (p->allow_save() ? "" : " (transient)") << "\n";
});
turret->set_property_value<int64_t>("ammo", int64_t{3});

auto watch = turret->heat.on_change.connect([](const int64_t& oldHeat, const int64_t& newHeat) {
    std::cout << "heat " << oldHeat << " -> " << newHeat << "\n";
});
turret->heat = 5;
turret->set_property_value<int64_t>("heat", int64_t{8});

ammo
cooldown (transient)
heat
name
range
heat 0 -> 5
heat 5 -> 8

• One declaration, four uses. The same five lines are what jai::to_json(*eng, turret) saves ("ammo": 3,"heat": 8,"name": "north","range": 12.5, the transient cooldown left out), what script reads and writes, and what an editor walks. There is no registration block to keep in step with the class.
• The walk is in name order within a level and starts with base levels. Turret::all_property_names() lists the names in declaration order without an instance.
• The notify signal is part of the property. on_change hands its receivers the old and the new value, where a Qt notify signal conventionally carries the new value or nothing. It fires only when the value changes, from C++ assignment, compound operators, set_property_value or a script store; heat.set_silent(v) writes without it, for loading.
• The range limit has no place to go. A property carries its name, its C++ type and its save and observe flags, nothing else. A limit is enforced by a setter (a binder .property(name, getter, setter)) and described to an editor by the host's own table.

From script, the same object:

for (auto f : reflect::fields(turret)) { print(f["name"], " ", f["type"], " ", f["kind"]); }
print(reflect::get(turret, "ammo"));
reflect::set(turret, "range", 20.0);
turret.heat.on_change([=](int old_value, int new_value) -> void { print("script sees heat ", old_value, " -> ", new_value); });
turret.heat = turret.heat + 1;

name string field
ammo int field
range float field
heat int observable
cooldown float field
3
heat 8 -> 9
script sees heat 8 -> 9

The C++ receiver fires too (heat 8 -> 9): one emitter, receivers on both sides.

What has no counterpart​

• Metadata and attributes. RTTR's metadata(key, value), refl-cpp's attributes and Qt's DESIGNABLE, SCRIPTABLE and USER flags have nothing to attach to.
• Compile-time iteration. refl-cpp's member list is a compile-time sequence templates expand over. JaiScript's is a run-time walk; generic code takes a property_base* and asks it for its type.
• Dynamic properties. Qt's setProperty with an undeclared name adds one to that object. set_property_value finds declared properties only, and returns false for any other name.
• RESET, REVISION, BINDABLE. No reset function, revisions or bindable properties; a binding that follows another value connects to its on_change.
• Enumerating methods from C++. Qt and RTTR list and invoke methods through the meta-object. A JaiScript class's methods are its binder entries in an engine; script lists them with reflect::methods and calls them with reflect::invoke.
• Properties on any class. RTTR and refl-cpp reflect a class without touching it. A JaiScript property lives in a property_owner; a class you cannot edit is bound with dynamic_binder .property lines, which script sees but the C++ walk does not.