refl-cpp v0.12.1

Documentation

refl-cpp encodes type metadata in the type system to allow compile-time reflection via constexpr and template metaprogramming in C++17

Introduction

refl-cpp aims to provide a generic static reflection system that can be extended to suit your needs. Runtime reflection can also be implemented on top of the existing system for when needed (see the examples).

Some nice things refl-cpp supports out-of-the-box:

• custom attributes - encodes type-level and member-level attributes as a constexpr std::tuple associated with that item
• proxy types - builds configurable generic types with identical member functions that can be hooked into to wrap or extend functionality
• overloaded functions - wraps member functions in generic variadic templates
• template functions - template function for which the template parameters can be inferred from the arguments are also supported
• template types - uses template specialization to encode metadata for types; template types are perfectly-well supported

Code Example (see on Compiler Explorer)

A basic example showcasing how refl-cpp can be use to convert an arbitrary type to a tuple at compile-time

// Custom attribute to mark fields for validation
struct NonNegative : refl::attr::usage::member {};

struct Point {
    double x, y;
};

REFL_AUTO(
    type(Point),
    field(x, NonNegative()),
    field(y, NonNegative())
)

struct Circle {
    Point origin;
    double radius;
};

REFL_AUTO(
    type(Circle),
    field(origin),
    field(radius, NonNegative())
)

template <typename T>
constexpr bool checkNonNegaive(const T& obj) {
    // Get the type descriptor for T
    constexpr auto type = refl::reflect<T>();
    // Get the compile-time refl::type_list<...> of member descriptors
    constexpr auto members = get_members(type);
    // Filter out the non-readable members (not field or getters marked with the property() attribute)
    constexpr auto readableMembers = filter(members, [](auto member) { return is_readable(member); });

    auto invalidMemberCount = count_if(readableMembers, [&](auto member) {
        // Function-call syntax is a uniform way to get the value of a member (whether a field or a getter)
        auto&& value = member(obj);
        // Check if the NonNegative attribute is present
        if constexpr (refl::descriptor::has_attribute<NonNegative>(member)) {
            // And if so, make the necessary checks
            return value < 0;
        }
        // Recursively check the value of the member
        else if (!checkNonNegaive(value)) {
            return true;
        }
        return false;
    });

    return invalidMemberCount == 0;
}

// These all run at compile-time
constexpr Circle c1{ {0., 5.}, 100. };
static_assert(checkNonNegaive(c1));

constexpr Circle c2{ {0., 5.}, -100. };
static_assert(!checkNonNegaive(c2));

constexpr Circle c3{ {0., -5.}, 100. };
static_assert(!checkNonNegaive(c3));

Requirements

• Minimum language standard: C++17

Usage

• refl-cpp is packaged as a single-header library. #include "refl.hpp" like any other header.

Contributing

• Issue tracker - refl-cpp/issues
• Source code - refl-cpp
• Contributors - refl-cpp/contributors.md

License

• MIT License (for more details, see the license file)