How to pass a enum variable to a struct with template specialization for enum

I design a struct with template specialization for enum, like this:

template<DataType type>
struct TypeTrait;

template<>
struct TypeTrait<DATA_TYPE_INT8> {
    static constexpr uint32_t size = sizeof(int8_t);
};

template<>
struct TypeTrait<DATA_TYPE_INT16> {
    static constexpr uint32_t size = sizeof(int16_t);
};

template<>
struct TypeTrait<DATA_TYPE_FP16> {
    static constexpr uint32_t size = sizeof(uint16_t);
};

template<>
struct TypeTrait<DATA_TYPE_UINT8> {
    static constexpr uint32_t size = sizeof(uint8_t);
};

template<>
struct TypeTrait<DATA_TYPE_UINT16> {
    static constexpr uint32_t size = sizeof(uint16_t);
};

template<>
struct TypeTrait<DATA_TYPE_INT32> {
    static constexpr uint32_t size = sizeof(int32_t);
};

template<>
struct TypeTrait<DATA_TYPE_UINT32> {
    static constexpr uint32_t size = sizeof(uint32_t);
};

template<>
struct TypeTrait<DATA_TYPE_FP32> {
    static constexpr uint32_t size = sizeof(float);
};

enum DataType is defined like this:

enum DataType {
    DATA_TYPE_INT8 = 0,
    DATA_TYPE_INT16 = 1,
    DATA_TYPE_FP16 = 2,
    DATA_TYPE_UINT8 = 3,
    DATA_TYPE_UINT16 = 4,
    DATA_TYPE_INT32 = 5,
    DATA_TYPE_UINT32 = 6,
    DATA_TYPE_FP32 = 7,
    DATA_TYPE_UNKOWN
};

And I want pass a DataType variable to struct TypeTrait, like this:

class Test {
public:
    ...

    void Convert() {
        ...
        uint32_t size = TypeTrait<type_>::size;
        ...
    }
private:
    DataType type_;
};

When I do this, there is a problem while compiling my program:

main.cc: In member function ‘void Test::Convert()’:
main.cc:63:35: error: use of ‘this’ in a constant expression
   63 |         uint32_t size = TypeTrait<type_>::size;
      |                                   ^~~~~
main.cc:63:40: error: use of ‘this’ in a constant expression
   63 |         uint32_t size = TypeTrait<type_>::size;
      |                                        ^
main.cc:63:35: note: in template argument for type ‘DataType’
   63 |         uint32_t size = TypeTrait<type_>::size;
      |                                   ^~~~~                              ^

I tried many ways, like convert type_ to be a const value, like this:

const DataType dataType = type_;
uint32_t size = TypeTrait<dataType>::size;

Then this problem arosed.

main.cc: In member function ‘void Test::Convert()’:
main.cc:63:39: error: the value of ‘type’ is not usable in a constant expression
   63 |         uint32_t size = TypeTrait<type>::size;
      |                                       ^
main.cc:62:24: note: ‘type’ was not initialized with a constant expression
   62 |         const DataType type = GetType();
      |                        ^~~~
main.cc:63:39: note: in template argument for type ‘DataType’
   63 |         uint32_t size = TypeTrait<type>::size;
      |         

I know the program will be no problem if I pass enum element like this.

uint32_t size = TypeTrait<DataType::DATA_TYPE_UINT32>::size;

I have no idea to solve this issue. So I must use switch case to handle this, which is against my wishes.
I just want to remove the switch case in my codes.
The code to be refactored:

    switch (dataType_) {
        case DATA_TYPE_INT8:
            byteSize = elemCnt * sizeof(int8_t);
            break;
        case DATA_TYPE_INT16:
            byteSize = elemCnt * sizeof(int16_t);
            break;
        case DATA_TYPE_FP16:
            byteSize = elemCnt * sizeof(uint16_t);
            break;
        case DATA_TYPE_UINT8:
            byteSize = elemCnt * sizeof(uint8_t);
            break;
        case DATA_TYPE_UINT16:
            byteSize = elemCnt * sizeof(uint16_t);
            break;
        case DATA_TYPE_INT32:
            byteSize = elemCnt * sizeof(int32_t);
            break;
        case DATA_TYPE_UINT32:
            byteSize = elemCnt * sizeof(uint32_t);
            break;
        case DATA_TYPE_FP32:
            byteSize = elemCnt * sizeof(float);
            break;
    }

Here is one way to fetch the TypeTrait<type>::size at runtime without a switch (C++17 required):

uint32_t datatypeSize(DataType type) {
    return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        return ((static_cast<std::size_t>(type) == Is ? TypeTrait<static_cast<DataType>(Is)>::size : 0) + ...);
    }(std::make_index_sequence<DATA_TYPE_UNKOWN>{});
}

Demo

Another, using std::array (from Jarod42's comment - C++17 as well):

uint32_t datatypeSize(DataType type) {
    return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::array{TypeTrait<static_cast<DataType>(Is)>::size...}[type];
    }(std::make_index_sequence<DATA_TYPE_UNKOWN>{});
}