Мапим значения на типы. Ч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.
