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

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

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

enum class DataType {
kInt32,
kDouble,
kUint64
};

template
T create_from_buffer(const void* buffer) {
static_assert(std::is_trivially_copyable_v,
"Type T must be trivially copyable");

T obj;
std::memcpy(&obj, buffer, sizeof(T));
return obj;
}

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

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

using DataVariant = std::variant;

DataVariant foo(const void* buffer, DataType type) {
switch (type) {
case DataType::kInt32:
return create_from_buffer(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 struct EnumMap;
template struct EnumMap { using Type = int32_t; };
template struct EnumMap { using Type = double; };
template struct EnumMap { using Type = uint64_t; };

template
using EnumMappedType = typename EnumMap::Type;

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

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

using DataVariant = std::variant;
using MakerFn = DataVariant()(const void);

template
constexpr auto make_table(std::index_sequence) {
return std::array{
+[](const void* buffer) -> DataVariant {
return create_from_buffer(buffer);
}...
};
}

static constexpr auto dispatcher =
make_table(std::make_index_sequence{});

Через fold expression делаем массив обработчиков для каждого элемента перечисления. Это гарантирует std::make_index_sequence, который раскрывается в последовательность индексов перечислителей вплоть до последнего kCount.

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

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

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

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

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

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

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

Divide and conquer. Stay cool.