Фабрика для std::variant: как объединить compile-time и run-time, чтобы получить выигрыш от обоих20.05.2024 15:45

Поправим наш класс Shape, чтобы получить возможность использовать наши нововведения:

#include "VariantFactory.h"

class Shape
{
public:
    using ShapeFactory = VariantFactory;

    enum ShapeType
    {
        ST_Invalid = -1,
        ST_Point,
        ST_Rect,
        ST_Line
    };

    explicit Shape(int key = ST_Invalid)
        : Shape(key)
    {
    }

    template
    Shape(int key, _Args&&... args)
    {
        if (key != ST_Invalid && !ShapeFactory{}.emplace(d, key, std::forward<_Args_>(args)...))
            std::cerr << "error: unable to create shape for key " << key << std::endl;
    }

    void draw(std::ostream& out) const
    {
        if (!d) {
            std::cerr << "error: shape was not set to an instance of an object" << std::endl;
            return;
        }
        std::visit([&out](const auto& s) { s.draw(out); }, *d);
    }

    int area() const
    {
         if (!d)
             return 0;
         return std::visit([](const auto& s) { return s.area(); }, *d);
    }

    explicit operator bool() const { return !!d; }

private:
    ShapeFactory::ResultType d;
};


int main()
{
    std::vector shapes;
    shapes.emplace_back(ST_Point, 10, 10);
    shapes.emplace_back(ST_Rect, -5, -5, 10, 10);
    shapes.emplace_back(ST_Line, 1, 1, 4, 5);
    shapes.emplace_back(Shape{});
    for (const auto& shape : shapes)
    {
        if (shape)
            shape.draw(std::cout);
        else
            std::cerr << "unable to draw shape" << std::endl;
    }
    // Output:
    // point: [10,10]
    // rect: [-5,5 (10x10)]
    // line: [(1,1),(4,5)]
    // unable to draw shape
}

Замечательно — теперь код компилируется и работает как задумывалось!

Здесь вроде бы можно было поставить точку, но мы пойдем еще дальше. Можно заметить, что нам необходимо следить за тем, чтобы порядок, в котором объявлены типы в нашей фабрике, в точности совпадал с порядком, в котором объявлены типы в Enum ShapeType. В нашем игрушечном примере сделать это не составляет труда. В реальности же код пишут и исправляют множество людей, и уследить за этим будет практически невозможно. Хорошей идеей будет придумать механизм, благодаря которому поведение фабрики не будет зависеть от порядка объявления типов.

Чтобы решить проблему, нам нужна некая таблица поиска, которая преобразует переданный ключ в нужный индекс внутри std: variant:

template
struct VariantFactory
{
    using VariantType = std::variant<_Types...>;
    using ResultType = std::optional;

    static constexpr size_t kTypeCount = sizeof...(_Types);
    static constexpr size_t kLookup[kTypeCount] = { ??? };

    template
    bool emplace(ResultType& result, int type, _Args&&... args) const
    {
        auto first = std::begin(kLookup);
        auto last = std::end(kLookup);
        auto it = std::find(first, last, type);
        if (it == last)
            return false;
        return emplaceVariant(result, std::distance(first, it), std::forward<_Args>(args)...);
    }

    // as before
    // ...
};

Теперь у нас следующая проблема: необходимо каким-то образом задать таблицу подстановки. Первое, что приходит на ум: пусть каждый тип сам говорит о себе свой идентификатор типа в Compile-time, например, так:

struct Point
{
    static constexpr size_t kElementType = Shape::ST_Point;
    // as before
    // ...
};

struct Rect
{
    static constexpr size_t kElementType = Shape::ST_Rect;
    // as before
    // ...
};

struct Line
{
    static constexpr size_t kElementType = Shape::ST_Line;
    // as before
    // ...
};

Это позволит нам сгенерировать таблицу подстановки в виде массива kLookup автоматически:

template
struct VariantFactory
{
   static constexpr size_t kTypeCount = sizeof...(_Types);
   static constexpr size_t kLookup[kTypeCount] = { _Types::kElementType... };
// as before ...
};

Правда, теперь мы ограничены тем, что тип обязан определить статическую константу времени компиляции с определенным именем. Чтобы избежать необходимости добавлять такие константы в каждый тип, можно создать шаблонный адаптер, который будет делать это автоматически и каждый из конечных типов наследовать от такого адаптера:

template
struct ShapeAdapter
{
    static constexpr kElementType = _ElemId;
};

struct Point : public ShapeAdapter
{
    // as before...
};

Если мы попробуем использовать VariantFactory более широко, то столкнемся с другой сложностью — требованием, чтобы каждый тип имел объявление kElementType, а нам хотелось бы иметь наиболее общее решение. Чтобы обойти это ограничение, можно прибегнуть к достаточно простому решению — наследовать от VariantFactory более конкретные классы-фабрики и предоставить механизм передачи таблицы подстановки в функцию создания. Например, так:

template
struct VariantFactory
{
    using VariantType = std::variant<_Types...>;
    using ResultType = std::optional;
    static constexpr size_t kTypeCount = sizeof...(_Types);

protected:
    template
    bool emplace(ResultType& result, int type, _Args&&... args) const
    {
        return createVariant(result, type, std::forward<_Args>(args)...);
    }

    bool emplace(ResultType& result, int type, int (&lookup)[kTypeCount], _Args&&... args) const
    {
        auto first = std::begin(lookup);
        auto last = std::end(lookup);
        auto it = std::find(first, last, type);
        if (it == last)
            return false;
        return emplaceVariant(result, std::distance(first, it), std::forward<_Args>(args)...);
    }

private:
    template 
    static bool emplaceVariant(ResultType& result, std::size_t index, _Args&&... args)
    {
        // as before...
    }
};

Теперь мы можем объявить реализацию для нашей конкретной фабрики следующим образом:

template
struct ShapeFactory : public VariantFactory<_Types...>
{
    static constexpr size_t kLookup[] = { _Types::kElementType... };

    bool createShape(ResultType& result, int type)
    {
        return this->emplace(result, type, kLookup);
    }
};

Это неплохое решение, достаточно надежное, но требует знаний шаблонов и метапрограммирования для реализации наследования от VariantFactory. Можем ли мы пойти еще дальше? Ответ — да!

Уникальные идентификаторы типа как ключи в фабрике

Следующий наш шаг будет заключаться в том, чтобы вовсе отказаться от каких-либо перечислений и ручной нумерации через Enum. Идея заключается в том, чтобы придумать механизм создания уникальных идентификаторов для типа в Compile-time. В каком-то смысле этот механизм напоминает RTTI (Run-Time Type Information), назовем его CTTI (Compile-Time Type Information). Сразу оговорюсь, что методика создания таких идентификаторов — обширная тема, достойная отдельной статьи. На просторах интернета можно найти десятки различных реализаций под самые разнообразные требования. Тут каждый найдет решение на свой вкус и потребности. Поэтому в качестве примера я решил использовать один из достаточно распространенных трюков — использование адресов статических переменных:

template
struct type { static constexpr char _dummy_ = 0; };

template
inline constexpr const void* kUniqueId = &type::_dummy_;

template
static size_t unique_id() { return reinterpret_cast(kUniqueId); }

int main()
{
    std::cout << "kUniqueId=" << (void*)kUniqueId << std::endl;
    std::cout << "kUniqueId=" << (void*)kUniqueId << std::endl;
    std::cout << "kUniqueId=" << (void*)kUniqueId << std::endl;

    std::cout << "unique_id()=" << (void*)kUniqueId << std::endl;
    std::cout << "unique_id()=" << (void*)kUniqueId << std::endl;
    std::cout << "unique_id()=" << (void*)kUniqueId << std::endl;

    // Possible output:
    // kUniqueId=0x4019d8
    // kUniqueId=0x4019d7
    // kUniqueId=0x4019d6
    // unique_id()=0x4019d8
    // unique_id()=0x4019d7
    // unique_id()=0x4019d6
}

Здесь стоит обратить особое внимание на то, что в результате инстанцирования kUniqueId мы получаем Const Void* указатели и не преобразуем их в какой-то целочисленный тип, хотя кажется, что это ничему не противоречит. Дело в том, что такое преобразование требует, чтобы переменная была в Run-time-контексте. Другими словами, если попытаться использовать такое приведение, то код не скомпилируется, если убрать constexpr, то лишимся Compile-time. Поэтому для Run-time-контекста мы используем обычную функцию unique_id (), возвращающую результат все того же kUniqueId.

Есть у такого подхода и недостатки. К основным относятся:

• адрес статической переменной и сами идентификаторы типа будут разными от компиляции к компиляции;
  
• возможны проблемы при переходе границ динамической библиотеки. Компилятор может посчитать такую переменную неиспользуемой и выкинуть ее при компиляции.
  

Это не означает, что такое решение не имеет права на существование: представленные варианты генерации уникальных идентификаторов не являются исчерпывающими. Выбор конкретного решения всегда обусловлен текущими обстоятельствами и потребностями конкретного продукта. В конце статьи я привел ресурсы, к которым можно обратиться, чтобы изучить проблему глубже и выбрать подходящий вариант.

Используя все эти знания, мы теперь можем написать финальную, наиболее общую реализацию VariantFactory:

#include "unique_id.h"

template
struct VariantFactory
{
    static constexpr size_t kTypeCount = sizeof...(_Types);
    static constexpr const void* kLookup[] = { kUniqueId<_Types>... };

    using VariantType = std::variant<_Types...>;
    using ResultType = std::optional;

    template
    using AlternativeType = std::variant_alternative_t;

    template
    bool operator()(ResultType& result, size_t type, _Args&&... args) const
    {
        for (size_t i = 0; i < kTypeCount; ++i)
            if (reinterpret_cast(kLookup[i]) == type)
                return emplaceVariant(result, I, std::forward<_Args>(args)...);
        return false;
    }

protected:
    template 
    static constexpr bool emplaceVariant(ResultType& result, std::size_t index, _Args&&... args)
    {
        if constexpr (I >= kTypeCount)
        {
            return false;
        }
        else
        {
            if (index == 0)
            {
                if constexpr (std::is_constructible, _Args...>{})
                {
                    result.emplace(std::in_place_index, std::forward<_Args>(args)...);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return emplaceVariant(result, index - 1, std::forward<_Args>(args)...);
        }
    }
};