reflect.h

#pragma once
 
#include <cstddef>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace Vkm::Engine::Reflect {

template<typename T>
inline constexpr bool DEPENDENT_FALSE = false;

template<typename T, typename M>
struct Field {
    std::string_view name;
    M T::*           ptr;
};
 
// `Field{"position", &Transform::position}` deduces T=Transform, M=glm::vec3.
template<typename T, typename M>
Field(const char*, M T::*) -> Field<T, M>;

template<typename T>
struct Traits;

template<typename T, typename Fn>
constexpr void forEachField(T& obj, Fn&& fn) {
    using Bare = std::remove_const_t<T>;
    constexpr auto tup = Traits<Bare>::fields();
    const auto visit = [&](auto&&... f) { ((fn(f.name, obj.*(f.ptr))), ...); };
    std::apply(visit, tup);
}

constexpr const char* shortName(const char* qualified) {
    const char* last = qualified;
    for (const char* p = qualified; *p; ++p) {
        if (p[0] == ':' && p[1] == ':') last = p + 2;
    }
    return last;
}

template<typename Enum>
struct EnumNames;

template<typename Enum>
constexpr const char* enumName(Enum value) {
    using Names = EnumNames<Enum>;
    const auto index = static_cast<std::size_t>(value);
    return index < Names::count ? Names::values[index] : Names::values[0];
}

template<typename Enum>
bool enumFromNameChecked(std::string_view name, Enum& out) {
    using Names = EnumNames<Enum>;
    for (std::size_t i = 0; i < Names::count; ++i) {
        if (name == Names::values[i]) {
            out = static_cast<Enum>(i);
            return true;
        }
    }
    return false;
}

template<typename T, typename = void>
inline constexpr bool IS_REFLECTED = false;
 
template<typename T>
inline constexpr bool IS_REFLECTED<T, std::void_t<decltype(Traits<T>::fields())>> = true;

template<typename Enum, typename = void>
inline constexpr bool HAS_ENUM_NAMES = false;
 
template<typename Enum>
inline constexpr bool HAS_ENUM_NAMES<Enum, std::void_t<decltype(EnumNames<Enum>::count)>> = true;
 
} // namespace Vkm::Engine::Reflect

#define VKM_REFLECT_BEGIN(Type)                                                        \
    namespace Vkm::Engine::Reflect {                                                   \
    template<> struct Traits<Type> {                                                   \
        using vkm_reflect_self = Type;                                                 \
        static constexpr const char* NAME = ::Vkm::Engine::Reflect::shortName(#Type); \
        static constexpr auto fields() {                                               \
            return std::tuple_cat(
 
#define VKM_F(name) \
    std::make_tuple(::Vkm::Engine::Reflect::Field{#name, &vkm_reflect_self::name}),
 
#define VKM_REFLECT_END()                                                              \
                std::tuple<>()                                                         \
            );                                                                         \
        }                                                                              \
    };                                                                                 \
    }

#define VKM_ENUM_NAMES(EnumType, ...)                                            \
    namespace Vkm::Engine::Reflect {                                             \
    template<> struct EnumNames<EnumType> {                                      \
        static constexpr const char* const values[] = { __VA_ARGS__ };           \
        static constexpr std::size_t count = sizeof(values) / sizeof(values[0]); \
        static_assert(                                                           \
            count == static_cast<std::size_t>(EnumType::Count),                  \
            #EnumType " names out of sync with its Count sentinel"               \
        );                                                                       \
    };                                                                           \
    }