scalar_type.hpp

 
#ifndef UFO_UTILITY_SCALAR_TYPE_HPP
#define UFO_UTILITY_SCALAR_TYPE_HPP
 
// STL
#include <concepts>
#include <cstdint>
#include <format>
#include <ostream>
#include <string_view>
#include <utility>
 
namespace ufo
{
enum class ScalarType : std::uint8_t {
    INT8    = 0,  
    UINT8   = 1,  
    INT16   = 2,  
    UINT16  = 3,  
    INT32   = 4,  
    UINT32  = 5,  
    INT64   = 6,  
    UINT64  = 7,  
    FLOAT32 = 8,  
    FLOAT64 = 9,  
    UNKNOWN = 10  
};
 
[[nodiscard]] constexpr std::string_view toString(ScalarType type) noexcept
{
    using enum ScalarType;
    switch (type) {
        case INT8: return "INT8";
        case UINT8: return "UINT8";
        case INT16: return "INT16";
        case UINT16: return "UINT16";
        case INT32: return "INT32";
        case UINT32: return "UINT32";
        case INT64: return "INT64";
        case UINT64: return "UINT64";
        case FLOAT32: return "FLOAT32";
        case FLOAT64: return "FLOAT64";
        case UNKNOWN: return "UNKNOWN";
    }
    std::unreachable();
}
 
inline std::ostream& operator<<(std::ostream& os, ScalarType type)
{
    return os << toString(type);
}
 
namespace detail
{
template <class T>
consteval ScalarType scalarTypeOf() noexcept
{
    using enum ScalarType;
    if constexpr (std::same_as<T, std::int8_t>) {
        return INT8;
    } else if constexpr (std::same_as<T, std::uint8_t>) {
        return UINT8;
    } else if constexpr (std::same_as<T, std::int16_t>) {
        return INT16;
    } else if constexpr (std::same_as<T, std::uint16_t>) {
        return UINT16;
    } else if constexpr (std::same_as<T, std::int32_t>) {
        return INT32;
    } else if constexpr (std::same_as<T, std::uint32_t>) {
        return UINT32;
    } else if constexpr (std::same_as<T, std::int64_t>) {
        return INT64;
    } else if constexpr (std::same_as<T, std::uint64_t>) {
        return UINT64;
    } else if constexpr (std::same_as<T, float>) {
        return FLOAT32;
    } else if constexpr (std::same_as<T, double>) {
        return FLOAT64;
    } else {
        return UNKNOWN;
    }
}
}  // namespace detail
 
template <class T>
constexpr inline ScalarType scalar_type_v = detail::scalarTypeOf<T>();
 
}  // namespace ufo
 
template <>
struct std::formatter<ufo::ScalarType> : std::formatter<std::string_view> {
    auto format(ufo::ScalarType type, std::format_context& ctx) const
    {
        return std::formatter<std::string_view>::format(ufo::toString(type), ctx);
    }
};
 
#endif  // UFO_UTILITY_SCALAR_TYPE_HPP