NBT_Type.hpp

浏览该文件的文档.

#pragma once
 
#include <stdint.h>
#include <stddef.h>//size_t
#include <variant>
#include <vector>
#include <unordered_map>
#include <string>
#include <type_traits>
 
#include "NBT_TAG.hpp"

 
class NBT_Node;
template <typename Array>
class NBT_Array;
template <typename String, typename StringView>
class NBT_String;
template <typename List>
class NBT_List;
template <typename Compound>
class NBT_Compound;

class NBT_Type
{
    NBT_Type(void) = delete;
    ~NBT_Type(void) = delete;
 
public:

    using Float_Raw = uint32_t;
    using Double_Raw = uint64_t;

 
    //内建类型
    //默认为无状态，与std::variant兼容
    using End           = std::monostate;   
    using Byte          = int8_t;           
    using Short         = int16_t;          
    using Int           = int32_t;          
    using Long          = int64_t;          
 
    //浮点类型
    //通过编译期确认类型大小来选择正确的类型，优先浮点类型，如果失败则替换为对应的可用类型
    using Float         = std::conditional_t<(sizeof(float) == sizeof(Float_Raw)), float, Float_Raw>;       
    using Double        = std::conditional_t<(sizeof(double) == sizeof(Double_Raw)), double, Double_Raw>;   
 
    //数组类型，不存在SortArray，由于NBT标准不提供，所以此处也不提供
    using ByteArray     = NBT_Array<std::vector<Byte>>; 
    using IntArray      = NBT_Array<std::vector<Int>>;  
    using LongArray     = NBT_Array<std::vector<Long>>; 
 
    //字符串类型
    using String        = NBT_String<std::basic_string<uint8_t>, std::basic_string_view<uint8_t>>;  
 
    //列表类型
    //存储一系列同类型标签的有效负载（无标签 ID 或名称），原先为list，因为mc内list也通过下标访问，所以改为vector模拟
    using List          = NBT_List<std::vector<NBT_Node>>;  
 
    //集合类型
    //挂在序列下的内容都通过map绑定名称
    using Compound      = NBT_Compound<std::unordered_map<String, NBT_Node>>;   


    template<typename... Ts>
    struct _TypeList{};

    using TypeList = _TypeList
    <
        End,
        Byte,
        Short,
        Int,
        Long,
        Float,
        Double,
        ByteArray,
        String,
        List,
        Compound,
        IntArray,
        LongArray
    >;
 
private:
    //通过类型Tag映射到字符串指针数组
    constexpr static inline const char *const cstrTypeName[] =
    {
        "End",
        "Byte",
        "Short",
        "Int",
        "Long",
        "Float",
        "Double",
        "ByteArray",
        "String",
        "List",
        "Compound",
        "IntArray",
        "LongArray",
    };
 
public:
    constexpr static inline const char *GetTypeName(NBT_TAG tag) noexcept//运行时类型判断，允许静态
    {
        if (tag >= NBT_TAG::ENUM_END)
        {
            return "Unknown";
        }
 
        NBT_TAG_RAW_TYPE tagRaw = (NBT_TAG_RAW_TYPE)tag;
        return cstrTypeName[tagRaw];
    }

    using ArrayLength = int32_t;    
    using StringLength = uint16_t;  
    using ListLength = int32_t;     

    constexpr static inline ArrayLength ArrayLength_Max = INT32_MAX;    
    constexpr static inline ArrayLength ArrayLength_Min = INT32_MIN;    
 
    constexpr static inline StringLength StringLength_Max = UINT16_MAX; 
    constexpr static inline StringLength StringLength_Min = 0;          
 
    constexpr static inline ListLength ListLength_Max = INT32_MAX;      
    constexpr static inline ListLength ListLength_Min = INT32_MIN;      
 

    constexpr static inline Byte Byte_Max = INT8_MAX;       
    constexpr static inline Byte Byte_Min = INT8_MIN;       
 
    constexpr static inline Short Short_Max = INT16_MAX;    
    constexpr static inline Short Short_Min = INT16_MIN;    
 
    constexpr static inline Int Int_Max = INT32_MAX;        
    constexpr static inline Int Int_Min = INT32_MIN;        
 
    constexpr static inline Long Long_Max = INT64_MAX;      
    constexpr static inline Long Long_Min = INT64_MIN;      

    template <typename T, typename List>
    struct IsValidType;
 
    template <typename T, typename... Ts>
    struct IsValidType<T, _TypeList<Ts...>> : std::bool_constant<(std::is_same_v<T, Ts> || ...)>
    {};

    template <typename T>
    static constexpr bool IsValidType_V = IsValidType<T, TypeList>::value;

    template <typename T, typename... Ts>
    static consteval NBT_TAG_RAW_TYPE TypeTagHelper()//consteval必须编译期求值
    {
        NBT_TAG_RAW_TYPE tagIndex = 0;
        bool bFound = ((std::is_same_v<T, Ts> ? true : (++tagIndex, false)) || ...);
        return bFound ? tagIndex : (NBT_TAG_RAW_TYPE)-1;
    }
 
    template <typename T, typename List>
    struct TypeTagImpl;
 
    template <typename T, typename... Ts>
    struct TypeTagImpl<T, _TypeList<Ts...>>
    {
        static constexpr NBT_TAG_RAW_TYPE value = TypeTagHelper<T, Ts...>();
    };

    template <typename T>
    static constexpr NBT_TAG TypeTag_V = (NBT_TAG)TypeTagImpl<T, TypeList>::value;

    template <typename List>
    struct TypeListSize;
 
    template <typename... Ts>
    struct TypeListSize<_TypeList<Ts...>>
    {
        static constexpr size_t value = sizeof...(Ts);
    };

    static constexpr size_t TypeListSize_V = TypeListSize<TypeList>::value;
 
    //静态断言：确保枚举值与类型数量匹配
    static_assert(TypeListSize_V == NBT_TAG::ENUM_END, "Enumeration does not match the number of types in the mutator");

    template <NBT_TAG_RAW_TYPE I, typename List> struct TypeAt;
 
    template <NBT_TAG_RAW_TYPE I, typename... Ts>
    struct TypeAt<I, _TypeList<Ts...>>
    {
        using type = std::tuple_element_t<I, std::tuple<Ts...>>;
    };
 
    template <NBT_TAG Tag>
    requires((NBT_TAG_RAW_TYPE)Tag < TypeListSize_V)
    struct TagToType
    {
        using type = typename TypeAt<(NBT_TAG_RAW_TYPE)Tag, TypeList>::type;
    };

    template <NBT_TAG Tag>
    using TagToType_T = typename TagToType<Tag>::type;
 

    
    template <typename T>
    static constexpr bool IsNumericType_V =
        std::is_same_v<T, Byte> ||
        std::is_same_v<T, Short> ||
        std::is_same_v<T, Int> ||
        std::is_same_v<T, Long> ||
        std::is_same_v<T, Float> ||
        std::is_same_v<T, Double>;

    template <typename T>
    static constexpr bool IsIntegerType_V =
        std::is_same_v<T, Byte> ||
        std::is_same_v<T, Short> ||
        std::is_same_v<T, Int> ||
        std::is_same_v<T, Long>;

    template <typename T>
    static constexpr bool IsFloatingType_V =
        std::is_same_v<T, Float> ||
        std::is_same_v<T, Double>;

    template <typename T>
    static constexpr bool IsArrayType_V =
        std::is_same_v<T, ByteArray> ||
        std::is_same_v<T, IntArray> ||
        std::is_same_v<T, LongArray>;

    template <typename T>
    static constexpr bool IsContainerType_V =
        std::is_same_v<T, ByteArray> ||
        std::is_same_v<T, IntArray> ||
        std::is_same_v<T, LongArray> ||
        std::is_same_v<T, List> ||
        std::is_same_v<T, Compound>;

    template <typename T>
    static constexpr bool IsStringType_V = std::is_same_v<T, String>;

    template <typename T>
    static constexpr bool IsListType_V = std::is_same_v<T, List>;

    template <typename T>
    static constexpr bool IsCompoundType_V = std::is_same_v<T, Compound>;


    template<typename T>
    requires(IsValidType_V<T> && IsNumericType_V<T>)
    struct BuiltinRawType
    {
        using Type = T;
    };

    template<typename T>
    using BuiltinRawType_T = typename BuiltinRawType<T>::Type;


    constexpr static inline bool IsNumericTag(NBT_TAG tag) noexcept
    {
        switch (tag)
        {
        case NBT_TAG::Byte:
        case NBT_TAG::Short:
        case NBT_TAG::Int:
        case NBT_TAG::Long:
        case NBT_TAG::Float:
        case NBT_TAG::Double:
            return true;
        default:
            return false;
        }
    }

    constexpr static inline bool IsIntegerTag(NBT_TAG tag) noexcept
    {
        switch (tag)
        {
        case NBT_TAG::Byte:
        case NBT_TAG::Short:
        case NBT_TAG::Int:
        case NBT_TAG::Long:
            return true;
        default:
            return false;
        }
    }

    constexpr static inline bool IsFloatingTag(NBT_TAG tag) noexcept
    {
        switch (tag)
        {
        case NBT_TAG::Float:
        case NBT_TAG::Double:
            return true;
        default:
            return false;
        }
    }

    constexpr static inline bool IsArrayTag(NBT_TAG tag) noexcept
    {
        switch (tag)
        {
        case NBT_TAG::ByteArray:
        case NBT_TAG::IntArray:
        case NBT_TAG::LongArray:
            return true;
        default:
            return false;
        }
    }

    constexpr static inline bool IsContainerTag(NBT_TAG tag) noexcept
    {
        switch (tag)
        {
        case NBT_TAG::ByteArray:
        case NBT_TAG::IntArray:
        case NBT_TAG::LongArray:
        case NBT_TAG::List:
        case NBT_TAG::Compound:
            return true;
        default:
            return false;
        }
    }

    constexpr static inline bool IsStringTag(NBT_TAG tag) noexcept
    {
        return tag == NBT_TAG::String;
    }

    constexpr static inline bool IsListTag(NBT_TAG tag) noexcept
    {
        return tag == NBT_TAG::List;
    }

    constexpr static inline bool IsCompoundTag(NBT_TAG tag) noexcept
    {
        return tag == NBT_TAG::Compound;
    }

};
 
//显示特化

template<>
struct NBT_Type::BuiltinRawType<NBT_Type::Float>//浮点数映射
{
    using Type = Float_Raw;
    static_assert(sizeof(Type) == sizeof(Float), "Type size does not match!");
};
 
template<>
struct NBT_Type::BuiltinRawType<NBT_Type::Double>//浮点数映射
{
    using Type = Double_Raw;
    static_assert(sizeof(Type) == sizeof(Double), "Type size does not match!");
};