Способ фильтрации объектов по типу на фабрике

В этом ответе предлагается написать собственную крошечную структуру «отражения во время выполнения». Будем надеяться, что однажды C++ будет иметь правильное отражение во время компиляции (или времени выполнения), и этот ответ устареет. До тех пор...

TL;DR: Живая демоверсия (обозреватель компилятора)

Базовая структура отражения

Нашей целью будет создание экземпляра нешаблонного класса TypeInfo для каждого типа возвращаемого значения фабрики. У этого типа есть функция-член bool isBaseOf(TypeInfo const& other), которую можно использовать во время выполнения и вести себя как std::is_base_of.

#include <span>

struct TypeTag{};
using TypeId =  TypeTag const*;

// This is NOT a templated class.
class TypeInfo {
public:
    using DirectBases = std::span<TypeInfo const* const>;

    explicit constexpr TypeInfo(TypeId typeId, DirectBases directBases)
        : typeId_{ typeId }
        , directBases_{ directBases }
    {}

    constexpr bool isBaseOf(TypeInfo const& child) const {
        if (*this == child) {
            return true;
        }
        for (TypeInfo const* directBase : child.directBases_) {
            if (isBaseOf(*directBase)) {
                return true;
            }
        }
        return false;
    }

    constexpr bool operator==(TypeInfo const& other) const {
        return typeId_ == other.typeId_;
    }
protected:
    TypeId typeId_;
    DirectBases directBases_;
};

И карта времени компиляции typename T -> TypeInfo{...}, действующая как база данных информации об отражениях:

template<typename T>
struct TypeInfoOf;

template<typename T>
constexpr TypeInfo const& typeInfoOf() {
    return TypeInfoOf<T>::value;
}

При этом getFilteredListOfTypes можно реализовать как:

#include <list>
#include <string>
#include <unordered_map>

// NOTE (digression): I see a singleton anti-pattern here...
class AppFactory {
public:
    struct RegisterMapValue {
        // CreateFunction func;
        TypeInfo const* typeInfo;
    };

    using RegisterMap = std::unordered_map<std::string, RegisterMapValue>;

    static RegisterMap& get() {
        static RegisterMap map;
        return map;
    }

    template<class T>
    static void add(const std::string& name) {
        get()[name] = { /*func,*/ &typeInfoOf<T>() };
    }

    static std::list<std::string> getFilteredListOfTypes(TypeInfo const& base) {
        std::list<std::string> typeList;
        for(auto const& mapPair : get()) {
            if (base.isBaseOf(*mapPair.second.typeInfo)) {
                typeList.push_back(mapPair.first);
            }
        }
        return typeList;
    }

    template<class BaseType>
    static std::list<std::string> getFilteredListOfTypes() {
        return getFilteredListOfTypes(typeInfoOf<BaseType>());
    }
};

Теперь, чтобы создать эти объекты TypeId, нам нужно сгенерировать две вещи.

• Уникальный TypeId объект для каждого типа.
• Массив/вектор TypeInfo*, содержащий прямые основания объекта.

Генерация уникального TypeId

template<typename T>
struct UniqueId {
    static constexpr auto tag = TypeTag{};
};

template<typename T>
constexpr TypeId uniqueTypeIdOf() {
    return &UniqueId<T>::tag;
}

static_assert(uniqueTypeIdOf<std::string>() == uniqueTypeIdOf<std::string>());
static_assert(uniqueTypeIdOf<unsigned>() != uniqueTypeIdOf<std::string>());

Генерация базового массива

К сожалению, мы не можем автоматически получить список прямых баз типа. Мы просто создадим утилиту, которая принимает базовые типы в качестве входных данных, превращает их в объект std::array<TypeInfo*> и создает объект TypeInfo:

#include <array>
#include <type_traits>

template<typename T, typename... DirectBases>
struct TypeInfoMaker {
private:
    static_assert((std::is_base_of_v<DirectBases,T> && ...));
    static_assert((!std::is_same_v<T,DirectBases> && ...));

    using BasesArray = std::array<TypeInfo const*, sizeof...(DirectBases)>;

    static constexpr auto directBases = BasesArray{ {&typeInfoOf<DirectBases>()...} };
public:
    static constexpr auto value = TypeInfo{ uniqueTypeIdOf<T>(), directBases };
};

Заполнение карты TypeInfoOf

Именно здесь проявляется главный недостаток этого ответа: список базового класса дублируется между объявлением класса и конструкцией TypeInfo. Оба должны быть обновлены вместе вручную (если только не используются макросы, но это будет некрасиво).

2 static_assert в TypeInfoMaker обеспечивают некоторую защиту от ошибок: TypeInfoMaker выдаст ошибку времени компиляции, если база неверна (но будет принимать косвенные базы), и должна предотвращать циклические ссылки (TypeInfo::isBaseOf завершится). Мы мало что можем сделать против пропавших баз.

// User-provided class (unchanged)
class A {
public:
    virtual ~A() = default;
};

// The user has to declare A's reflection data as follows:
template<>
struct TypeInfoOf<A> : TypeInfoMaker<A> {};

class B : public A {};

template<>
struct TypeInfoOf<B> : TypeInfoMaker<B, A> {};

class C : public B {};

template<>
struct TypeInfoOf<C> : TypeInfoMaker<C, B> {};

class D : public C {};

template<>
struct TypeInfoOf<D> : TypeInfoMaker<D, C> {};

class E : public B {};

template<>
struct TypeInfoOf<E> : TypeInfoMaker<E, B> {};

С другой стороны, для заполнения карты TypeInfoOf требуется всего пара строк каждого типа.

Демо/использование

Объедините все предыдущие фрагменты кода и добавьте следующее:

#include <iostream>
#include <string_view>

template<typename T>
void printFilteredList(std::string_view typeName) {
    std::cout << "filteredListOfTypes<" << typeName << ">: ";
    for (auto const& value : AppFactory::getFilteredListOfTypes<T>()) {
        std::cout << value << ' ';
    }
    std::cout << '\n';
}

int main() {
    AppFactory::add<A>("A");
    AppFactory::add<B>("B");
    AppFactory::add<C>("C");
    AppFactory::add<D>("D");
    AppFactory::add<E>("E");

    printFilteredList<A>("A");
    printFilteredList<B>("B");
    printFilteredList<C>("C");
    printFilteredList<D>("D");
    printFilteredList<E>("E");
}

Живая демо-версия (проводник компилятора)