Обработка стертых данных во время выполнения — как не изобретать велосипед?

Цель здесь должна заключаться в том, чтобы как можно быстрее вернуться к системе типов C++. Для этого должна быть одна центральная функция, которая переключается на основе (времени выполнения) data_type, а затем передает каждый случай версии шаблона (времени компиляции).

Вы не указали, как выглядят связанные функции, но вот пример:

template<typename T>
struct TypedBuffer
{
  TypedBuffer(void* data, size_t elementCount) { /* ... */ }
  // ...
};

template<typename T>
void handleBufferTyped(void* data, size_t elementCount)
{
  TypedBuffer<T> buf(data, elementCount);
  // Do whatever you want - you're back in the type system.
}

void handleBuffer(buffer buf)
{
  switch (buf.element_type)
  {
  case INT16:     handleBufferTyped<int16_t>(buf.data, buf.size); break;
  case INT32:     handleBufferTyped<int32_t>(buf.data, buf.size); break;
  case UINT64:    handleBufferTyped<uint64_t>(buf.data, buf.size); break;
  case FLOAT:     handleBufferTyped<float>(buf.data, buf.size); break;
  case TIMESTAMP: handleBufferTyped<std::time_t>(buf.data, buf.size); break;
  }
}

При необходимости вы также можете наследовать TypedBuffer от базового класса без шаблона, чтобы вы могли вернуться из handleBuffer полиморфно, но это смешивает множество парадигм и, вероятно, не нужно.

как не изобретать велосипед?

Просто используйте std::variant вместе с конверсиями туда и обратно. Он находится в стандартной библиотеке по какой-то причине.

Если говорить об изобретении велосипеда, то посещение — это простейший общий механизм для обработки данных со стертым типом.

enum data_type { INT16 = 0, INT32, UINT64, FLOAT, TIMESTAMP, size };

template<data_type d>
struct data
{
    using type = void;
};
template<>
struct data<INT16>
{
    using type = int16_t;
};
// and so on

template<data_type d>
using data_t = typename data<d>::type;


template<typename F, typename T>
void indirect(void* f, void* t, int n)
{
    (*(F*)f)((T*)t, n);
}

template<typename F, size_t... Is>
void visit_(F&& f, buffer* bufs, int n, std::index_sequence<Is...>)
{
    using rF = typename std::remove_reference<F>::type;
    using f_t = void(*)(void*, void*, int);
    static constexpr f_t fs[] = {indirect<rF, data_t<data_type(Is)>>...};
    for(int i = 0; i < n; i++)
        fs[bufs[i].element_type](&f, bufs[i].data, bufs[i].size);
}

template<typename F>
void visit(F&& f, buffer* bufs, int n)
{
    visit_(std::forward<F>(f), bufs, n, std::make_index_sequence<data_type::size>{});
}

std::index_sequence и друзья могут быть относительно легко реализованы на C++11. Использовать как

struct printer
{
    template<typename T>
    void operator()(T* t, int n)
    {
        for(int i = 0; i < n; i++)
            std::cout << t[i] << ' ';
        std::cout << '\n';
    }
};

void foo()
{
    visit(printer{}, nullptr, 0);
}

Кажется, для этого используются type_traits (https://en.cppreference.com/w/cpp/types).

По сути, вы определяете шаблонную структуру, по умолчанию она пуста, и вы специфицируете ее для каждого перечисления, которое у вас есть. Затем в своем коде вы используете MyTypeTraits<MyEnumValue>::type, чтобы получить тип, связанный с нужным перечислением.

И все определяется во время компиляции. Если вам нужна информация о времени выполнения, вы всегда можете выполнить некоторую отправку на основе значения шаблона (например, если вы также храните перечисление).

Используйте boost::variant и gsl::span.

enum data_type { INT16 = 0, INT32, UINT64, FLOAT, TIMESTAMP };
struct buffer {
  data_type element_type;
  size_t    size; // in elements of element_type, not bytes
  void*     data;
};

template<class...Ts>
using var_span = boost::variant< gsl::span< Ts > ... >;

using buffer_span = var_span< std::int16_t, std::int32_t, std::uint64_t, float, ??? >;

buffer_span to_span( buffer buff ) {
  switch (buff.element_type) {
    case INT16: return gsl::span<std::int16_t>( (std::int16_t*)buff.data, buff.size );
    // etc
  }
}

Теперь вы можете

auto span = to_span( buff );

а затем посетите диапазон для безопасного доступа к буферу данных.

Запись посетителей менее болезненна в c+ +14 из-за [](auto&&) лямбда-выражений, но выполнимо в С++11.

Написание template<class...Fs> struct overloaded также может облегчить запись посетителей. Существует множество реализаций.

Если вы не можете использовать boost, вы можете преобразовать to_span в visit_span и заставить его принять посетителя.

Если вы не можете использовать gsl, написание собственного span тривиально.

visit_span( buff, overload(
  [](span<int16_t> span) { /* code */ },
  [](span<int32_t> span) { /* code */ },
  // ...
 ));

or

 struct do_foo {
   template<class T>
   void operator()(span<T> span) { /* code */ }
 };
 visit_span( buff, do_foo{captures} );