NBT_Reader.hpp

浏览该文件的文档.

#pragma once
 
#include <new>//std::bad_alloc
#include <bit>//std::bit_cast
#include <vector>//字节流
#include <stdint.h>//类型定义
#include <stddef.h>//size_t
#include <stdlib.h>//byte swap
#include <utility>//std::move
#include <type_traits>//类型约束
 
#include "NBT_Print.hpp"//打印输出
#include "NBT_Node.hpp"//nbt类型
#include "NBT_Endian.hpp"//字节序
#include "NBT_IO.hpp"//IO流对象

 

class NBT_Reader
{
    NBT_Reader(void) = delete;
    ~NBT_Reader(void) = delete;
 
protected:
    enum ErrCode : uint8_t
    {
        AllOk = 0,//没有问题
 
        UnknownError,//其他错误（代码问题）
        StdException,//标准异常（代码问题）
        ListElementTypeError,//列表元素类型错误（NBT文件问题）
        OutOfMemoryError,//内存不足错误（NBT文件问题）
        StackDepthExceeded,//调用栈深度过深（NBT文件or代码设置问题）
        NbtTypeTagError,//NBT标签类型错误（NBT文件问题）
        OutOfRangeError,//（NBT内部长度错误溢出）（NBT文件问题）
 
        ERRCODE_END,//结束标记，统计负数部分大小
    };
 
    constexpr static inline const char *const errReason[] =
    {
        "AllOk",
        "UnknownError",
        "StdException",
        "ListElementTypeError",
        "OutOfMemoryError",
        "StackDepthExceeded",
        "NbtTypeTagError",
        "OutOfRangeError",
    };
 
    //记得同步数组！
    static_assert(sizeof(errReason) / sizeof(errReason[0]) == ERRCODE_END, "errReason array out sync");
 
    enum WarnCode : uint8_t
    {
        NoWarn = 0,
 
        ElementExistsWarn,
 
        WARNCODE_END,
    };
 
    constexpr static inline const char *const warnReason[] =//正常数组，直接用WarnCode访问
    {
        "NoWarn",
 
        "ElementExistsWarn",
    };
 
    //记得同步数组！
    static_assert(sizeof(warnReason) / sizeof(warnReason[0]) == WARNCODE_END, "warnReason array out sync");
 
    //error处理
    //使用变参形参表+vprintf代理复杂输出，给出更多扩展信息
    //主动检查引发的错误，主动调用eRet = Error报告，然后触发STACK_TRACEBACK，最后返回eRet到上一级
    //上一级返回的错误通过if (eRet != AllOk)判断的，直接触发STACK_TRACEBACK后返回eRet到上一级
    //如果是警告值，则不返回值
    template <typename T, typename InputStream, typename InfoFunc, typename... Args>
    requires(std::is_same_v<T, ErrCode> || std::is_same_v<T, WarnCode>)
    static std::conditional_t<std::is_same_v<T, ErrCode>, ErrCode, void> Error
    (
        const T code,
        const InputStream &tData,
        InfoFunc &funcInfo,
        const std::format_string<Args...> fmt,
        Args&&... args
    ) noexcept
    {
        NBT_Print_Level lvl;
 
        //打印错误原因
        if constexpr (std::is_same_v<T, ErrCode>)
        {
            lvl = NBT_Print_Level::Err;
            if (code >= ERRCODE_END)
            {
                return code;
            }
            //上方if保证code不会溢出
            funcInfo(lvl, "Read Err[{}]: {}\n", (uint8_t)code, errReason[code]);
        }
        else if constexpr (std::is_same_v<T, WarnCode>)
        {
            lvl = NBT_Print_Level::Warn;
            if (code >= WARNCODE_END)
            {
                return;
            }
            //上方if保证code不会溢出
            funcInfo(lvl, "Read Warn[{}]: {}\n", (uint8_t)code, warnReason[code]);
        }
        else
        {
            static_assert(false, "Unknown [T code] Type!");
        }
 
        //打印扩展信息
        funcInfo(lvl, "Extra Info: \"");
        funcInfo(lvl, std::move(fmt), std::forward<Args>(args)...);
        funcInfo(lvl, "\"\n\n");
 
        //如果可以，预览szCurrent前后n个字符，否则裁切到边界
#define VIEW_PRE (4 * 8 + 3)//向前
#define VIEW_SUF (4 * 8 + 5)//向后
        size_t rangeBeg = (tData.Index() > VIEW_PRE) ? (tData.Index() - VIEW_PRE) : (0);//上边界裁切
        size_t rangeEnd = ((tData.Index() + VIEW_SUF) < tData.Size()) ? (tData.Index() + VIEW_SUF) : (tData.Size());//下边界裁切
#undef VIEW_SUF
#undef VIEW_PRE
        //输出信息
        funcInfo
        (
            lvl,
            "Data Review:\n"\
            "Current: 0x{:02X}({})\n"\
            "Data Size: 0x{:02X}({})\n"\
            "Data Range: [0x{:02X}({}),0x{:02X}({})):\n",
 
            (uint64_t)tData.Index(), tData.Index(),
            (uint64_t)tData.Size(), tData.Size(),
            (uint64_t)rangeBeg, rangeBeg,
            (uint64_t)rangeEnd, rangeEnd
        );
        
        //打数据
        for (size_t i = rangeBeg; i < rangeEnd; ++i)
        {
            if ((i - rangeBeg) % 8 == 0)//输出地址
            {
                if (i != rangeBeg)//除去第一个每8个换行
                {
                    funcInfo(lvl, "\n");
                }
                funcInfo(lvl, "0x{:02X}: ", (uint64_t)i);
            }
 
            if (i != tData.Index())
            {
                funcInfo(lvl, " {:02X} ", (uint8_t)tData[i]);
            }
            else//如果是当前出错字节，加方括号框起
            {
                funcInfo(lvl, "[{:02X}]", (uint8_t)tData[i]);
            }
        }
 
        //输出提示信息
        if constexpr (std::is_same_v<T, ErrCode>)
        {
            funcInfo(lvl, "\nSkip err data and return...\n\n");
        }
        else if constexpr (std::is_same_v<T, WarnCode>)
        {
            funcInfo(lvl, "\nSkip warn data and continue...\n\n");
        }
        else
        {
            static_assert(false, "Unknown [T code] Type!");
        }
 
        //警告不返回值
        if constexpr (std::is_same_v<T, ErrCode>)
        {
            return code;
        }
    }
 
 
#define _RP___FUNCTION__ __FUNCTION__//用于编译过程二次替换达到函数内部
 
#define _RP___LINE__ _RP_STRLING(__LINE__)
#define _RP_STRLING(l) STRLING(l)
#define STRLING(l) #l
 
#define STACK_TRACEBACK(fmt, ...) funcInfo(NBT_Print_Level::Err, "In [{}] Line:[" _RP___LINE__ "]: \n" fmt "\n\n", _RP___FUNCTION__ __VA_OPT__(,) __VA_ARGS__);
#define CHECK_STACK_DEPTH(depth) \
if((depth) == 0)\
{\
    eRet = Error(StackDepthExceeded, tData, funcInfo, "{}: NBT nesting depth exceeded maximum call stack limit", _RP___FUNCTION__);\
    STACK_TRACEBACK(#depth " == 0");\
    return eRet;\
}
 
#define MYTRY \
try\
{
 
#define MYCATCH \
}\
catch(const std::bad_alloc &e)\
{\
    ErrCode eRet = Error(OutOfMemoryError, tData, funcInfo, "{}: Info:[{}]", _RP___FUNCTION__, e.what());\
    STACK_TRACEBACK("catch(std::bad_alloc)");\
    return eRet;\
}\
catch(const std::exception &e)\
{\
    ErrCode eRet = Error(StdException, tData, funcInfo, "{}: Info:[{}]", _RP___FUNCTION__, e.what());\
    STACK_TRACEBACK("catch(std::exception)");\
    return eRet;\
}\
catch(...)\
{\
    ErrCode eRet =  Error(UnknownError, tData, funcInfo, "{}: Info:[Unknown Exception]", _RP___FUNCTION__);\
    STACK_TRACEBACK("catch(...)");\
    return eRet;\
}
 
    //读取大端序数值，bNoCheck为true则不进行任何检查
    template<bool bNoCheck = false, typename T, typename InputStream, typename InfoFunc>
    requires std::integral<T>
    static inline std::conditional_t<bNoCheck, void, ErrCode> ReadBigEndian(InputStream &tData, T &tVal, InfoFunc &funcInfo) noexcept
    {
        if constexpr (!bNoCheck)
        {
            if (!tData.HasAvailData(sizeof(T)))
            {
                ErrCode eRet = Error(OutOfRangeError, tData, funcInfo, "tData size [{}], current index [{}], remaining data size [{}], but try to read [{}]",
                    tData.Size(), tData.Index(), tData.Size() - tData.Index(), sizeof(T));
                STACK_TRACEBACK("HasAvailData Test");
                return eRet;
            }
        }
 
        T BigEndianVal{};
        tData.GetRange((void *)&BigEndianVal, sizeof(BigEndianVal));
        tVal = NBT_Endian::BigToNativeAny(BigEndianVal);
 
        if constexpr (!bNoCheck)
        {
            return AllOk;
        }
    }
 
    template<typename InputStream, typename InfoFunc>
    static ErrCode GetName(InputStream &tData, NBT_Type::String &tName, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        ErrCode eRet = AllOk;
        //读取2字节的无符号名称长度
        NBT_Type::StringLength wStringLength = 0;//w->word=2*byte
        eRet = ReadBigEndian(tData, wStringLength, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("wStringLength Read");
            return eRet;
        }
 
        //验证完成，类型转换
        using ValueType = NBT_Type::String::value_type;
        size_t szStringLength = (size_t)wStringLength;
        size_t szStringSize = szStringLength * sizeof(ValueType);
 
        //判断长度是否超过
        if (!tData.HasAvailData(szStringSize))
        {
            ErrCode eRet = Error(OutOfRangeError, tData, funcInfo, "{}:\n(Index[{}] + szStringLength[{}])[{}] > DataSize[{}]", __FUNCTION__,
                tData.Index(), szStringLength, tData.Index() + szStringLength, tData.Size());
            STACK_TRACEBACK("HasAvailData Test");
            return eRet;
        }
        
        //解析出名称
        tName.resize(szStringLength);//设置大小
        tData.GetRange((void *)tName.data(), szStringSize);//构造string（如果长度为0则构造0长字符串，合法行为）
 
        return eRet;
    MYCATCH;
    }
 
    template<typename T, typename InputStream, typename InfoFunc>
    static ErrCode GetBuiltInType(InputStream &tData, T &tBuiltIn, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
 
        //读取数据
        using RAW_DATA_T = NBT_Type::BuiltinRawType_T<T>;//类型映射
 
        //临时存储，因为可能存在跨类型转换
        RAW_DATA_T tTmpRawData = 0;
        eRet = ReadBigEndian(tData, tTmpRawData, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("tTmpRawData Read");
            return eRet;
        }
 
        //转换并返回
        tBuiltIn = std::move(std::bit_cast<T>(tTmpRawData));
        return eRet;
    }
 
    template<typename T, typename InputStream, typename InfoFunc>
    static ErrCode GetArrayType(InputStream &tData, T &tArray, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        ErrCode eRet = AllOk;
 
        //获取4字节有符号数，代表数组元素个数
        NBT_Type::ArrayLength iArrayLength = 0;//4byte
        eRet = ReadBigEndian(tData, iArrayLength, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("iArrayLength Read");
            return eRet;
        }
 
        //检查有符号数大小范围
        if (iArrayLength < 0)
        {
            eRet = Error(OutOfRangeError, tData, funcInfo, ":\niArrayLength[{}] < 0", __FUNCTION__, iArrayLength);
            STACK_TRACEBACK("iArrayLength Test");
            return eRet;
        }
 
        //验证完成，类型转换
        using ValueType = typename T::value_type;
        size_t szArrayLength = (size_t)iArrayLength;
        size_t szArraySize = szArrayLength * sizeof(ValueType);
 
        //判断长度是否超过
        if (!tData.HasAvailData(szArraySize))//保证下方调用安全
        {
            eRet = Error(OutOfRangeError, tData, funcInfo, "{}:\n(Index[{}] + szArraySize[{}])[{}] > DataSize[{}]", __FUNCTION__,
                tData.Index(), szArrayLength, tData.Index() + szArraySize, tData.Size());
            STACK_TRACEBACK("HasAvailData Test");
            return eRet;
        }
        
        //数组保存
        tArray.reserve(szArrayLength);//提前扩容
 
        //读取dElementCount个元素
        for (size_t i = 0; i < szArrayLength; ++i)
        {
            ValueType tTmpData{};
            ReadBigEndian<true>(tData, tTmpData, funcInfo);//调用需要确保范围安全
            tArray.emplace_back(std::move(tTmpData));//读取一个插入一个
        }
 
        return eRet;
    MYCATCH;
    }
 
    //如果是非根部，有额外检测
    template<bool bRoot, bool bUnwrapMixedList, typename InputStream, typename InfoFunc>
    static ErrCode GetCompoundType(InputStream &tData, NBT_Type::Compound &tCompound, size_t szStackDepth, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        ErrCode eRet = AllOk;
        CHECK_STACK_DEPTH(szStackDepth);
 
        //读取
        while (true)
        {
            //处理末尾情况
            if (!tData.HasAvailData(sizeof(NBT_TAG_RAW_TYPE)))
            {
                if constexpr (!bRoot)//非根部情况遇到末尾，则报错
                {
                    eRet = Error(OutOfRangeError, tData, funcInfo, "{}:\nIndex[{}] >= DataSize()[{}]", __FUNCTION__,
                        tData.Index(), tData.Size());
                    STACK_TRACEBACK("HasAvailData Test");
                }
 
                return eRet;//否则直接返回（默认值AllOk）
            }
 
            //先读取一下类型
            NBT_TAG_RAW_TYPE u8CompoundEntryTag = (NBT_TAG_RAW_TYPE)tData.GetNext();
            if (u8CompoundEntryTag == NBT_TAG::End)//处理End情况
            {
                return eRet;//直接返回（默认值AllOk）
            }
 
            if (u8CompoundEntryTag >= NBT_TAG::ENUM_END)//确认在范围内
            {
                eRet = Error(NbtTypeTagError, tData, funcInfo, "{}:\nNBT Tag switch default: Unknown Type Tag[0x{:02X}({})]", __FUNCTION__,
                    u8CompoundEntryTag, u8CompoundEntryTag);
                STACK_TRACEBACK("u8CompoundEntryTag Test");
                return eRet;//超出范围立刻返回
            }
 
            //验证完成，类型转换
            NBT_TAG enCompoundEntryTag = (NBT_TAG)u8CompoundEntryTag;
 
            //然后读取名称
            NBT_Type::String sName{};
            eRet = GetName(tData, sName, funcInfo);
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("GetName Error, Type: [NBT_Type::{}]", NBT_Type::GetTypeName(enCompoundEntryTag));
                return eRet;//名称读取失败立刻返回
            }
 
            //然后根据类型，调用对应的类型读取并返回到tmpNode
            NBT_Node tmpNode{};
            eRet = GetSwitch<bUnwrapMixedList>(tData, tmpNode, enCompoundEntryTag, szStackDepth - 1, funcInfo);
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("GetSwitch Error, Name: \"{}\", Type: [NBT_Type::{}]", sName.ToCharTypeUTF8(), NBT_Type::GetTypeName(enCompoundEntryTag));//注意这里ToCharTypeUTF8可能抛异常
                //return eRet;//注意此处不返回，进行插入，以便分析错误之前的正确数据
            }
 
            //sName:tmpNode，插入当前调用栈深度的根节点
            //根据实际mc java代码得出，如果插入一个已经存在的键，会导致原先的值被替换并丢弃
            //那么在失败后，手动从迭代器替换当前值，注意，此处必须是try_emplace，因为try_emplace失败后原先的值
            //tmpNode不会被移动导致丢失，所以也无需拷贝插入以防止移动丢失问题
            auto [it, bSuccess] = tCompound.try_emplace(std::move(sName), std::move(tmpNode));
            if (!bSuccess)
            {
                //使用当前值替换掉阻止插入的原始值
                it->second = std::move(tmpNode);
 
                //发出警告，注意警告不用eRet接返回值
                Error(ElementExistsWarn, tData, funcInfo, "{}:\nName: \"{}\", Type: [NBT_Type::{}] data already exist!", __FUNCTION__,
                    sName.ToCharTypeUTF8(), NBT_Type::GetTypeName(enCompoundEntryTag));//注意这里ToCharTypeUTF8可能抛异常
            }
 
            //最后判断是否出错
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("While break with an error!");
                return eRet;//出错返回
            }
        }
 
        return eRet;//返回错误码
    MYCATCH;
    }
 
    template<typename InputStream, typename InfoFunc>
    static ErrCode GetStringType(InputStream &tData, NBT_Type::String &tString, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
 
        //读取字符串
        eRet = GetName(tData, tString, funcInfo);//因为string与name读取原理一致，直接借用实现
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("GetString");//因为是借用实现，所以这里小小的改个名，防止报错Name误导人
            return eRet;
        }
 
        return eRet;
    }
 
    template<bool bUnwrapMixedList, typename InputStream, typename InfoFunc>
    static ErrCode GetListType(InputStream &tData, NBT_Type::List &tList, size_t szStackDepth, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        ErrCode eRet = AllOk;
        CHECK_STACK_DEPTH(szStackDepth);
 
        //读取1字节的列表元素类型
        NBT_TAG_RAW_TYPE u8ListElementTag = 0;//b=byte
        eRet = ReadBigEndian(tData, u8ListElementTag, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("u8ListElementTag Read");
            return eRet;
        }
 
        //错误的列表元素类型
        if (u8ListElementTag >= NBT_TAG::ENUM_END)
        {
            eRet = Error(NbtTypeTagError, tData, funcInfo, "{}:\nList NBT Type:Unknown Type Tag[0x{:02X}({})]", __FUNCTION__,
                (NBT_TAG_RAW_TYPE)u8ListElementTag, (NBT_TAG_RAW_TYPE)u8ListElementTag);
            STACK_TRACEBACK("u8ListElementTag Test");
            return eRet;
        }
 
        //验证完成，类型转换
        NBT_TAG enListElementTag = (NBT_TAG)u8ListElementTag;
 
        //读取4字节的有符号列表长度
        NBT_Type::ListLength iListLength = 0;//4byte
        eRet = ReadBigEndian(tData, iListLength, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("iListLength Read");
            return eRet;
        }
 
        //检查有符号数大小范围
        if (iListLength < 0)
        {
            eRet = Error(OutOfRangeError, tData, funcInfo, ":\niListLength[{}] < 0", __FUNCTION__, iListLength);
            STACK_TRACEBACK("iListLength Test");
            return eRet;
        }
 
        //验证完成，类型转换
        size_t szListLength = (size_t)iListLength;
 
        //防止重复N个结束标签，带有结束标签的必须是空列表
        if (enListElementTag == NBT_TAG::End && szListLength != 0)
        {
            eRet = Error(ListElementTypeError, tData, funcInfo, "{}:\nThe list with TAG_End[0x00] tag must be empty, but [{}] elements were found", __FUNCTION__,
                szListLength);
            STACK_TRACEBACK("enListElementTag And szListLength Test");
            return eRet;
        }
 
        //确保如果长度为0的情况下，列表类型必为End
        if (szListLength == 0 && enListElementTag != NBT_TAG::End)
        {
            enListElementTag = NBT_TAG::End;
        }
 
        //提前扩容
        tList.reserve(szListLength);//已知大小提前分配减少开销
 
        //根据元素类型，读取n次列表
        for (size_t i = 0; i < szListLength; ++i)
        {
            NBT_Node tmpNode{};//列表元素会直接赋值修改
            eRet = GetSwitch<bUnwrapMixedList>(tData, tmpNode, enListElementTag, szStackDepth - 1, funcInfo);
            if (eRet != AllOk)//错误处理
            {
                STACK_TRACEBACK("GetSwitch Error, Size: [{}] Index: [{}]", szListLength, i);
                return eRet;
            }
 
            //每读取一个往后插入一个
            if constexpr (!bUnwrapMixedList)//正常插入
            {
                tList.emplace_back(std::move(tmpNode));
            }
            else//尝试解包插入
            {
                auto *pNode = &tmpNode;
                do
                {
                    if (enListElementTag != NBT_TAG::Compound)
                    {
                        break;
                    }
 
                    //尝试解包：只有一个无名称根
                    auto &cpdNode = tmpNode.GetCompound();//此处可能抛异常
                    if (cpdNode.Size() != 1)
                    {
                        break;
                    }
 
                    auto *pFind = cpdNode.Has(MU8STR(""));
                    if (pFind == NULL)
                    {
                        break;//没找到，说明是普通Compound
                    }
 
                    pNode = pFind;//找到了！
                } while (0);
 
                tList.emplace_back(std::move(*pNode));
            }
        }
        
        return eRet;
    MYCATCH;
    }
 
    //这个函数拦截所有内部调用产生的异常并处理返回，所以此函数绝对不抛出异常，由此调用此函数的函数也可无需catch异常
    template<bool bUnwrapMixedList, typename InputStream, typename InfoFunc>
    static ErrCode GetSwitch(InputStream &tData, NBT_Node &nodeNbt, NBT_TAG tagNbt, size_t szStackDepth, InfoFunc &funcInfo) noexcept//选择函数不检查递归层，由函数调用的函数检查
    {
        ErrCode eRet = AllOk;
 
        switch (tagNbt)
        {
        case NBT_TAG::Byte:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Byte>;
                eRet = GetBuiltInType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Short:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Short>;
                eRet = GetBuiltInType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Int:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Int>;
                eRet = GetBuiltInType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Long:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Long>;
                eRet = GetBuiltInType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Float:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Float>;
                eRet = GetBuiltInType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Double:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Double>;
                eRet = GetBuiltInType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::ByteArray:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::ByteArray>;
                eRet = GetArrayType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::String:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::String>;
                eRet = GetStringType(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::List://需要递归调用，列表开头给出标签ID和长度，后续都为一系列同类型标签的有效负载（无标签 ID 或名称）
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::List>;
                eRet = GetListType<bUnwrapMixedList>(tData, nodeNbt.Set<CurType>(), szStackDepth, funcInfo);//选择函数不减少递归层
            }
            break;
        case NBT_TAG::Compound://需要递归调用
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Compound>;
                eRet = GetCompoundType<false, bUnwrapMixedList>(tData, nodeNbt.Set<CurType>(), szStackDepth, funcInfo);//选择函数不减少递归层
            }
            break;
        case NBT_TAG::IntArray:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::IntArray>;
                eRet = GetArrayType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::LongArray:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::LongArray>;
                eRet = GetArrayType<CurType>(tData, nodeNbt.Set<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::End://不应该在任何时候遇到此标签，Compound会读取到并消耗掉，不会传入，List遇到此标签不会调用读取，所以遇到即为错误
            {
                eRet = Error(NbtTypeTagError, tData, funcInfo, "{}:\nNBT Tag switch error: Unexpected Type Tag NBT_TAG::End[0x00(0)]", __FUNCTION__);
            }
            break;
        default://其它未知标签，如NBT内标数据签错误
            {
                eRet = Error(NbtTypeTagError, tData, funcInfo, "{}:\nNBT Tag switch error: Unknown Type Tag[0x{:02X}({})]", __FUNCTION__,
                    (NBT_TAG_RAW_TYPE)tagNbt, (NBT_TAG_RAW_TYPE)tagNbt);//此处不进行提前返回，往后默认返回处理
            }
            break;
        }
        
        if (eRet != AllOk)//如果出错，打一下栈回溯
        {
            STACK_TRACEBACK("Tag[0x{:02X}({})] read error!",
                (NBT_TAG_RAW_TYPE)tagNbt, (NBT_TAG_RAW_TYPE)tagNbt);
        }
 
        return eRet;//传递返回值
    }
 
public:
    /*
    备注：此函数读取nbt时，会创建一个默认根，然后把nbt内所有数据集合到此默认根上，
    也就是哪怕按照mojang的nbt标准，默认根是无名Compound，也会被挂接到返回值里的
    NBT_Type::Compound中。遍历函数返回的NBT_Type::Compound即可得到所有NBT数据，
    这么做的目的是为了方便读写例程且不用在某些地方部分实现mojang的无名compound的
    特殊处理，这种情况下可以在一定程度上甚至比mojang标准支持更多的NBT文件情况，
    比如文件内并不是Compound开始的，而是单纯的几个不同类型且带有名字的NBT，那么也能
    正常读取到并全部挂在NBT_Type::Compound中，就好像nbt文件本身就是一个大的无名
    NBT_Type::Compound一样，相对的，写出函数也能支持写出此种情况，所以写出函数
    WriteNBT在写出的时候，传入的值也是一个内含NBT_Type::Compound的NBT_Node，
    然后传入的NBT_Type::Compound本身不会被以任何形式写入NBT文件，而是内部数据，
    也就是挂接在下面的内容会被写入，这样既能保证兼容mojang的nbt文件，也能一定程度上
    扩展nbt文件内可以存储的内容（允许nbt文件直接存储多个键值对而不是必须先挂在一个
    无名称的Compound下）
    */
 
    //szStackDepth 控制栈深度，递归层检查仅由可嵌套的可能进行递归的函数进行，栈深度递减仅由对选择函数的调用进行
    //注意此函数不会清空tCompound，所以可以对一个tCompound通过不同的tData多次调用来读取多个nbt片段并合并到一起
    //如果指定了szDataStartIndex则会忽略tData中长度为szDataStartIndex的数据

    template<bool bUnwrapMixedList = true, typename InputStream, typename InfoFunc = NBT_Print>
    static bool ReadNBT(InputStream &IptStream, NBT_Type::Compound &tCompound, size_t szStackDepth = 512, InfoFunc funcInfo = InfoFunc{}) noexcept//从data中读取nbt
    {
        return GetCompoundType<true, bUnwrapMixedList>(IptStream, tCompound, szStackDepth, funcInfo) == AllOk;//从data中获取nbt数据到nRoot中，只有此调用为根部调用（模板true），用于处理特殊情况
    }

    template<bool bUnwrapMixedList = true, typename DataType = std::vector<uint8_t>, typename InfoFunc = NBT_Print>
    static bool ReadNBT(const DataType &tDataInput, size_t szStartIdx, NBT_Type::Compound &tCompound, size_t szStackDepth = 512, InfoFunc funcInfo = InfoFunc{}) noexcept//从data中读取nbt
    {
        NBT_IO::DefaultInputStream<DataType> IptStream(tDataInput, szStartIdx);
        return GetCompoundType<true, bUnwrapMixedList>(IptStream, tCompound, szStackDepth, funcInfo) == AllOk;
    }
 
#ifdef CJF2_NBT_CPP_USE_ZLIB

    template <typename InfoFunc = NBT_Print>
    static bool SimpleReadNbtFile(const std::filesystem::path &pathFileName, NBT_Type::Compound &tCompound, InfoFunc funcInfo = InfoFunc{}) noexcept
    {
        //读取文件
        std::vector<uint8_t> vFileData;
        if (!NBT_IO::ReadFile(pathFileName, vFileData, funcInfo))
        {
            funcInfo(NBT_Print_Level::Err, "Error: Cannot read file [{}].\n", pathFileName.string());
            return false;
        }
 
        //尝试解压，失败则视作未压缩数据
        std::vector<uint8_t> vNbtData;
        if (!NBT_IO::DecompressDataNoThrow(vNbtData, vFileData, funcInfo))
        {
            funcInfo(NBT_Print_Level::Warn, "Warning: Decompression failed, assuming uncompressed data.\n");
            vNbtData = std::move(vFileData);
        }
 
        //清理数据
        vFileData.clear();
        vFileData.shrink_to_fit();
 
        //读取
        if (!ReadNBT(vNbtData, 0, tCompound, 512, funcInfo))
        {
            funcInfo(NBT_Print_Level::Err, "Error: ReadNBT failed.\n");
            return false;
        }
 
        return true;
    }
 
#endif
 
#undef MYTRY
#undef MYCATCH
#undef CHECK_STACK_DEPTH
#undef STACK_TRACEBACK
#undef STRLING
#undef _RP_STRLING
#undef _RP___LINE__
#undef _RP___FUNCTION__
};