Automatically built list of child types about refl-cpp HOT 2 CLOSED

#include <string>
#include <vector>
#include <map>
#include <iostream>
#include "refl.hpp"

#define CONCAT_(A, B) A##B
#define CONCAT(A, B) CONCAT_(A, B)
#define RUN_GLOBAL(...) static int CONCAT(_ignored_, __COUNTER__) = (void(__VA_ARGS__), 0)

struct TypeInfo
{
    template <typename T>
    static TypeInfo from(refl::type_descriptor<T> td)
    {
        auto bases = refl::util::map_to_array<TypeInfo>(reflect_types(get_declared_base_types(td)), [](auto base_td) {
            return TypeInfo::from(base_td);
        });
        return TypeInfo{ td.name.str(), std::vector<TypeInfo>(bases.begin(), bases.end()) };
    }

    template <typename T>
    static void register_type()
    {
        constexpr auto td = refl::reflect<T>();
        s_type_info[td.name.str()] = from(td);
    }

    template <typename T>
    static std::vector<TypeInfo> get_derived_types()
    {
        std::vector<TypeInfo> derived;
        for (auto&& [key, value] : s_type_info) {
            for (auto&& base : value.bases) {
                if (base.name == refl::reflect<T>().name.str()) {
                    // TODO: Check if already added
                    derived.push_back(value);
                }
            }
        }
        return derived;
    }

    std::string name;
    std::vector<TypeInfo> bases; 
    static std::map<std::string, TypeInfo> s_type_info;
};

std::map<std::string, TypeInfo> TypeInfo::s_type_info{ };

struct BaseClass { };
REFL_AUTO(type(BaseClass))
RUN_GLOBAL(TypeInfo::register_type<BaseClass>());

struct DerivedClass : BaseClass { };
REFL_AUTO(type(DerivedClass, bases<BaseClass>))
RUN_GLOBAL(TypeInfo::register_type<DerivedClass>());

int main()
{
    std::cout << "Derived from BaseClass:\n";
    for (auto&& derived : TypeInfo::get_derived_types<BaseClass>()) {
        std::cout << '\t' << derived.name << '\n';
    }
}