Мапим значения на типы. Ч1
#опытным

Иногда требуется на основе какого-то рантайм значения, например перечисления, получить какой-то соответствующий тип.

Например, у вас есть шаблонная функция и вы хотите вызвать правильную ее инстанциацию:

enum class DataType { 
    kInt32,
    kDouble,
    kUint64
};

template<typename T>
T create_from_buffer(const void* buffer) {
    static_assert(std::is_trivially_copyable_v<T>,
                  "Type T must be trivially copyable");
    
    T obj;
    std::memcpy(&obj, buffer, sizeof(T));
    return obj;
}

Как на основе DataType создать объект нужного типа?

Пойдем доисторическим способом. Там, где есть enum, всегда где-то в углу стоит застенчивый switch и хочет быть использован. Ну давайте попробуем:

using DataVariant = std::variant<int32_t, double, uint64_t>;

DataVariant foo(const void* buffer, DataType type) {
    switch (type) {
        case DataType::kInt32:
            return create_from_buffer<int32_t>(buffer);
        // ...
        default:
            throw std::runtime_error("Unknown type");
    }
}

И это вроде работает. Но не зря switch стоит в углу:

1️⃣ Он смешивает логику выбора, соответствия сущностей и обработки

2️⃣ Часто он приводит к длинным функциям, которые сложно поддерживать

3️⃣ switch может и быстрый, но засоряет клиентский код.

К тому же код кучу раз повторяется конкретно в этом кейсе.

Давайте пробовать решать.

Если наш enum плотный aka вы не присваивали никаким перечислителям числа, то можно примерно все красиво вынести в compile-time.

Начнем с того, что нужно создать compile-time маппинг между типами и перечислителями. Это поможет в коде отделить логику соответствия enum'а и типов:

enum class DataType { kInt32, kDouble, kUint64, kCount };  
  
template <DataType> struct EnumMap;  
template <> struct EnumMap<DataType::kInt32> { using Type = int32_t; };  
template <> struct EnumMap<DataType::kDouble> { using Type = double; };  
template <> struct EnumMap<DataType::kUint64> { using Type = uint64_t; };  
  
template <DataType D>  
using EnumMappedType = typename EnumMap<D>::Type;

Используем полную специализацию шаблонов и зависимые типы.

Дальше нужна логика обработки

using DataVariant = std::variant<int32_t, double, uint64_t>;  
using MakerFn = DataVariant(*)(const void*);

template <std::size_t... Is>
constexpr auto make_table(std::index_sequence<Is...>) {
    return std::array<MakerFn, sizeof...(Is)>{
        +[](const void* buffer) -> DataVariant {
            return create_from_buffer<EnumMappedType<static_cast<DataType>(Is)>>(buffer);
        }...
    };
}

static constexpr auto dispatcher =
    make_table(std::make_index_sequence<static_cast<std::size_t>(DataType::kCount)>{});

Через раскрытие пака параметров делаем массив обработчиков для каждого элемента перечисления. Это гарантирует std::make_index_sequence<static_cast<std::size_t>(DataType::kCount)>, который раскрывается в последовательность индексов перечислителей вплоть до последнего kCount.

Для этого и было условие плотности enum'а, чтобы make_index_sequence корректно передавал индексы.

Для каждого обработчика выбираем нужный тип через EnumMappedType.

Плюсик перед лямбдой кастит ее к указателю на функцию. Это чтобы не использовать опасный для перфа std::function.

Ну а логику выбора написать уже очень просто:

DataVariant foo(const void* buffer, DataType type) {
    auto idx = static_cast<std::size_t>(type);
    if (idx >= dispatcher.size())
        throw std::runtime_error("Unknown type");
    return dispatcher[idx](buffer);
}

Итого, мы явно разделили 3 задачи: описание обработчиков, маппинг и сам выбор обработчика.

Да, код все еще повторяется при описании маппинга EnumMap. Однако этот код намного более атомарно фундаментальный чтоли. Намного менее вероятно, что он изменится, потому что в нем зашита только необходимый маппинг и больше ничего. Можно делать через туплы парных сущностей, но выглядело бы это сильно менее понятным.

Divide and conquer. Stay cool.