NBT_Writer.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 <algorithm>//std::sort
 
#include "NBT_Print.hpp"//打印输出
#include "NBT_Node.hpp"//nbt类型
#include "NBT_Endian.hpp"//字节序
#include "NBT_IO.hpp"//IO流对象


class NBT_Writer
{
    NBT_Writer(void) = delete;
    ~NBT_Writer(void) = delete;
 
protected:
    enum ErrCode : uint8_t
    {
        AllOk = 0,//没有问题
 
        UnknownError,//其他错误（代码问题）
        StdException,//标准异常（代码问题）
        OutOfMemoryError,//内存不足错误（代码问题）
        StackDepthExceeded,//调用栈深度过深（代码问题）
        StringTooLongError,//字符串过长错误（代码问题）
        ArrayTooLongError,//数组过长错误（代码问题）
        ListTooLongError,//列表过长错误（代码问题）
        NbtTypeTagError,//NBT标签类型错误（代码问题）
 
        ERRCODE_END,//结束标记
    };
 
    constexpr static inline const char *const errReason[] =
    {
        "AllOk",
 
        "UnknownError",
        "StdException",
        "OutOfMemoryError",
        "StackDepthExceeded",
        "StringTooLongError",
        "ArrayTooLongError",
        "ListTooLongError",
        "NbtTypeTagError",
    };
 
    //记得同步数组！
    static_assert(sizeof(errReason) / sizeof(errReason[0]) == (ERRCODE_END), "errReason array out sync");
 
    enum WarnCode : uint8_t
    {
        NoWarn = 0,
 
        EndElementIgnoreWarn,
 
        WARNCODE_END,
    };
 
    constexpr static inline const char *const warnReason[] =//正常数组，直接用WarnCode访问
    {
        "NoWarn",
 
        "EndElementIgnoreWarn",
    };
 
    //记得同步数组！
    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 OutputStream, 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 OutputStream &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, "Write 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, "Write 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 (8 * 8 + 8)//向前
        size_t rangeBeg = (tData.Size() > VIEW_PRE) ? (tData.Size() - VIEW_PRE) : (0);//上边界裁切
        size_t rangeEnd = tData.Size();//下边界裁切
#undef VIEW_PRE
        //输出信息
        funcInfo
        (
            lvl,
            "Data Review:\n"\
            "Data Size: 0x{:02X}({})\n"\
            "Data Range: [0x{:02X}({}),0x{:02X}({})):\n",
 
            (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);
            }
 
            funcInfo(lvl, " {:02X} ", (uint8_t)tData[i]);
        }
 
        //输出提示信息
        if constexpr (std::is_same_v<T, ErrCode>)
        {
            funcInfo(lvl, "\nSkip err and return...\n\n");
        }
        else if constexpr (std::is_same_v<T, WarnCode>)
        {
            funcInfo(lvl, "\nSkip warn 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;\
}
 
    template<typename OutputStream, typename InfoFunc>
    static inline ErrCode CheckReserve(OutputStream &tData, size_t szAddSize, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        tData.AddReserve(szAddSize);
        return AllOk;
    MYCATCH;
    }
 
    //写出大端序值
    template<typename T, typename OutputStream, typename InfoFunc>
    requires std::integral<T>
    static inline ErrCode WriteBigEndian(OutputStream &tData, const T &tVal, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        auto BigEndianVal = NBT_Endian::NativeToBigAny(tVal);
        tData.PutRange((const uint8_t *)&BigEndianVal, sizeof(BigEndianVal));
        return AllOk;
    MYCATCH;
    }
 
    template<typename OutputStream, typename InfoFunc>
    static ErrCode PutName(OutputStream &tData, const NBT_Type::String &sName, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        ErrCode eRet = AllOk;
 
        //获取string长度
        size_t szStringLength = sName.size();
 
        //检查大小是否符合上限
        if (szStringLength > (size_t)NBT_Type::StringLength_Max)
        {
            eRet = Error(StringTooLongError, tData, funcInfo, "{}:\nszStringLength[{}] > StringLength_Max[{}]", __FUNCTION__,
                szStringLength, (size_t)NBT_Type::StringLength_Max);
            STACK_TRACEBACK("szStringLength Test");
            return eRet;
        }
 
        //输出名称长度
        NBT_Type::StringLength wStringLength = (NBT_Type::StringLength)szStringLength;
        eRet = WriteBigEndian(tData, wStringLength, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("wStringLength Write");
            return eRet;
        }
 
        using ValueType = NBT_Type::String::value_type;
        size_t szStringSize = szStringLength * sizeof(ValueType);
 
        //输出名称
        eRet = CheckReserve(tData, szStringSize, funcInfo);//提前分配
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("CheckReserve Error, Check Size: [{}]", szStringSize);
            return eRet;
        }
        //范围写入
        tData.PutRange((const typename OutputStream::ValueType *)sName.data(), szStringSize);
 
        return eRet;
    MYCATCH;
    }
 
    template<typename T, typename OutputStream, typename InfoFunc>
    static ErrCode PutbuiltInType(OutputStream &tData, const T &tBuiltIn, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
 
        //获取原始类型，然后转换到raw类型准备写出
        using RAW_DATA_T = NBT_Type::BuiltinRawType_T<T>;//原始类型映射
        RAW_DATA_T tTmpRawData = std::bit_cast<RAW_DATA_T>(tBuiltIn);
 
        eRet = WriteBigEndian(tData, tTmpRawData, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("tTmpRawData Write");
            return eRet;
        }
 
        return eRet;
    }
 
    template<typename T, typename OutputStream, typename InfoFunc>
    static ErrCode PutArrayType(OutputStream &tData, const T &tArray, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
 
        //获取数组大小判断是否超过要求上限
        //也就是4字节有符号整数上限
        size_t szArrayLength = tArray.size();
        if (szArrayLength > (size_t)NBT_Type::ArrayLength_Max)
        {
            eRet = Error(ArrayTooLongError, tData, funcInfo, "{}:\nszArrayLength[{}] > ArrayLength_Max[{}]", __FUNCTION__,
                szArrayLength, (size_t)NBT_Type::ArrayLength_Max);
            STACK_TRACEBACK("szArrayLength Test");
            return eRet;
        }
 
        //获取实际写出大小
        NBT_Type::ArrayLength iArrayLength = (NBT_Type::ArrayLength)szArrayLength;
        eRet = WriteBigEndian(tData, iArrayLength, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("iArrayLength Write");
            return eRet;
        }
 
        using ValueType = typename T::value_type;
        size_t szArraySize = szArrayLength * sizeof(ValueType);
 
        //写出元素
        eRet = CheckReserve(tData, szArraySize, funcInfo);//提前分配
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("CheckReserve Error, Check Size: [{}]", szArraySize);
            return eRet;
        }
 
        for (size_t i = 0; i < szArrayLength; ++i)
        {
            eRet = WriteBigEndian(tData, tArray[i], funcInfo);
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("tTmpData Write");
                return eRet;
            }
        }
 
        return eRet;
    }
 
    template<typename SortPolicy, typename OutputStream, typename InfoFunc>
    static ErrCode PutCompoundEntry(OutputStream &tData, const NBT_Type::String &sName, const NBT_Node &nodeNbt, size_t szStackDepth, InfoFunc &funcInfo)//它不是noexcept的
    {
        ErrCode eRet = AllOk;
 
        //获取类型
        NBT_TAG enCompoundEntryTag = nodeNbt.GetTag();
 
        //集合中如果存在nbt end类型的元素，删除而不输出
        if (enCompoundEntryTag == NBT_TAG::End)
        {
            //End元素被忽略警告（警告不返回错误码）
            Error(EndElementIgnoreWarn, tData, funcInfo, "{}:\nName: \"{}\", type is [NBT_Type::End], ignored!", __FUNCTION__,
                sName.ToCharTypeUTF8());//此处ToCharTypeUTF8可能抛异常
            return eRet;
        }
 
        //先写出tag
        eRet = WriteBigEndian(tData, (NBT_TAG_RAW_TYPE)enCompoundEntryTag, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("enCompoundEntryTag Write");
            return eRet;
        }
 
        //然后写出name
        eRet = PutName(tData, sName, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("PutName Error, Type: [NBT_Type::{}]", NBT_Type::GetTypeName(enCompoundEntryTag));
            return eRet;
        }
 
        //最后根据tag类型写出数据
        eRet = PutSwitch<SortPolicy>(tData, nodeNbt, enCompoundEntryTag, szStackDepth - 1, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("PutSwitch Error, Name: \"{}\", Type: [NBT_Type::{}]",
                sName.ToCharTypeUTF8(), NBT_Type::GetTypeName(enCompoundEntryTag));//此处ToCharTypeUTF8可能抛异常
            return eRet;
        }
 
        return eRet;
    }
 
    template<typename OutputStream, typename InfoFunc>
    static ErrCode PutCompoundEnd(OutputStream &tData, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
        
        //注意Compound类型有一个NBT_TAG::End结尾
        eRet = WriteBigEndian(tData, (NBT_TAG_RAW_TYPE)NBT_TAG::End, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("NBT_TAG::End[0x00(0)] Write");
            return eRet;
        }
 
        return eRet;
    }
 
    //如果是非根部，则会输出额外的Compound_End
    template<bool bRoot, typename SortPolicy, typename OutputStream, typename InfoFunc>
    static ErrCode PutCompoundType(OutputStream &tData, const NBT_Type::Compound &tCompound, size_t szStackDepth, InfoFunc &funcInfo) noexcept
    {
    MYTRY;
        ErrCode eRet = AllOk;
        CHECK_STACK_DEPTH(szStackDepth);
        
        using IterableRangeType = typename std::conditional_t<std::is_same_v<SortPolicy, NoSortCompound>, const NBT_Type::Compound &, std::vector<NBT_Type::Compound::Const_Iterator>>;
 
        //通过模板SortPolicy指定是否执行排序输出（nbt中仅compound是无序结构）
        IterableRangeType tmpIterableRange =//注意此处如果内部抛出异常，返回空vector的情况下还有可能二次异常，所以外部还需另一个try catch
        [&](void) noexcept -> IterableRangeType
        {
            if constexpr (std::is_same_v<SortPolicy, NoSortCompound>)
            {
                return tCompound;
            }
            else
            {
                try//筛掉标准库异常
                {
                    return SortPolicy{}(tCompound);
                }
                catch (const std::bad_alloc &e)
                {
                    eRet = Error(OutOfMemoryError, tData, funcInfo, "{}: Info:[{}]", _RP___FUNCTION__, e.what());
                    STACK_TRACEBACK("catch(std::bad_alloc)");
                    return {};
                }
                catch (const std::exception &e)
                {
                    eRet = Error(StdException, tData, funcInfo, "{}: Info:[{}]", _RP___FUNCTION__, e.what());
                    STACK_TRACEBACK("catch(std::exception)");
                    return {};
                }
                catch (...)
                {
                    eRet = Error(UnknownError, tData, funcInfo, "{}: Info:[Unknown Exception]", _RP___FUNCTION__);
                    STACK_TRACEBACK("catch(...)");
                    return {};
                }
            }
        }();
 
        //判断错误码是否被设置
        if constexpr (!std::is_same_v<SortPolicy, NoSortCompound>)//如果不是非排序提示（也就是要进行排序），则判断返回值
        {
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("Lambda: GetIterableRange Error!");
                return eRet;
            }
        }
 
        //注意compound是为数不多的没有元素数量限制的结构
        //此处无需检查大小，且无需写出大小
        for (const auto &it: tmpIterableRange)
        {
            const auto &[sName, nodeNbt] = [&](void) -> const auto &
            {
                if constexpr (std::is_same_v<SortPolicy, NoSortCompound>)
                {
                    return it;//非排序类型是引用，直接返回
                }
                else
                {
                    return *it;//排序获得迭代器，解引用返回
                }
            }();//立刻调用
 
            eRet = PutCompoundEntry<SortPolicy>(tData, sName, nodeNbt, szStackDepth, funcInfo);
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("PutCompoundEntry");
                return eRet;
            }
        }
 
        if constexpr (!bRoot)
        {
            eRet = PutCompoundEnd(tData, funcInfo);
            if (eRet != AllOk)
            {
                STACK_TRACEBACK("PutCompoundEnd");
                return eRet;
            }
        }
 
        return eRet;
    MYCATCH;
    }
 
    template<typename OutputStream, typename InfoFunc>
    static ErrCode PutStringType(OutputStream &tData, const NBT_Type::String &tString, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
 
        eRet = PutName(tData, tString, funcInfo);//借用PutName实现，因为string走的name相同操作
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("PutString");//因为是借用实现，所以这里小小的改个名，防止报错Name误导人
            return eRet;
        }
 
        return eRet;
    }
 
    template<typename SortPolicy, typename OutputStream, typename InfoFunc>
    static ErrCode PutListType(OutputStream &tData, const NBT_Type::List &tList, size_t szStackDepth, InfoFunc &funcInfo) noexcept
    {
        ErrCode eRet = AllOk;
        CHECK_STACK_DEPTH(szStackDepth);
 
        //转换为写入大小
        size_t szListEmptyEntryLength = 0;//统计空元素数量
 
        //获取列表标签
        bool bNeedWarp = false;
        NBT_TAG enListElementTag = NBT_TAG::End;
 
        //判断列表元素一致性，不一致则使用Compound封装
        for (const auto &it : tList)
        {
            NBT_TAG curTag = it.GetTag();
            if (curTag == NBT_TAG::End)
            {
                ++szListEmptyEntryLength;//统计空元素数量
                continue;//空元素没有后续判断必要性，跳过
            }
 
            //如果已经确定需要进行替换，则跳过
            if (bNeedWarp == true)
            {
                continue;
            }
 
            //如果列表元素值为End，那么替换为当前类型
            if (enListElementTag == NBT_TAG::End)
            {
                enListElementTag = curTag;
                continue;
            }
            
            //类型不同则设为替换类型
            if (enListElementTag != curTag)
            {
                bNeedWarp = true;
                enListElementTag = NBT_TAG::Compound;//修改为Compound封装
            }
        }
 
        //执行到这里：如果tList为空，那么enListElementTag恰好为End，符合0长度且为End的情况
        //如果List不为空：
        //元素不同：bNeedWarp为true且enListElementTag为Compound
        //元素相同：bNeedWarp为false且enListElementTag为列表元素类型
 
        //检查
        //仅判断去除空元素后是否超出上限
        size_t szListLength = tList.size();
        size_t szListNoEmptyEntryLength = szListLength - szListEmptyEntryLength;
        if (szListNoEmptyEntryLength > (size_t)NBT_Type::ListLength_Max)//大于的情况下强制赋值会导致严重问题，只能返回错误
        {
            eRet = Error(ListTooLongError, tData, funcInfo, "{}:\nszListNoEmptyEntryLength[{}] > ListLength_Max[{}]", __FUNCTION__,
                szListNoEmptyEntryLength, (size_t)NBT_Type::ListLength_Max);
            STACK_TRACEBACK("szListLength Test");
            return eRet;
        }
 
        //写出标签
        eRet = WriteBigEndian(tData, (NBT_TAG_RAW_TYPE)enListElementTag, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("enListElementTag Write");
            return eRet;
        }
 
        //写出长度，不包含空元素，所以减去iListEmptyEntryLength
        NBT_Type::ListLength iListLength = (NBT_Type::ListLength)szListNoEmptyEntryLength;
        eRet = WriteBigEndian(tData, iListLength, funcInfo);
        if (eRet != AllOk)
        {
            STACK_TRACEBACK("iListLength Write");
            return eRet;
        }
 
        //写出列表（递归）
        for (size_t i = 0; i < szListLength; ++i)//注意遍历仍然需要遍历整个列表而不是仅szListNoEmptyEntryLength，因为空元素可以在任何位置
        {
            //获取元素与类型
            const NBT_Node &tmpNode = tList[i];
            NBT_TAG curTag = tmpNode.GetTag();
 
            if (curTag == NBT_TAG::End)//空元素跳过
            {
                //End元素被忽略警告（警告不返回错误码）
                Error(EndElementIgnoreWarn, tData, funcInfo, "{}:\ntList[{}] type is [NBT_Type::End], ignored!", __FUNCTION__, i);
                continue;//跳过
            }
            
            if (!bNeedWarp)//不需要封装，直接写出
            {
                //列表无名字，无需重复tag，只需输出数据
                eRet = PutSwitch<SortPolicy>(tData, tmpNode, enListElementTag, szStackDepth - 1, funcInfo);//同一元素类型List
 
                if (eRet != AllOk)
                {
                    STACK_TRACEBACK("PutSwitch Error, Size: [{}] Index: [{}]", szListLength, i);
                    return eRet;
                }
            }
            else//需要封装，添加Compound
            {
                //如果元素本身就是Compound，那么检测是否和封装模式匹配，是的话再套一层防止丢失语义
                
                if (curTag == NBT_TAG::Compound)
                {
                    const auto &cpdNode = tmpNode.GetCompound();
                    if (cpdNode.Size() != 1 || !cpdNode.Contains(MU8STR("")))//直接写出为Compound
                    {
                        eRet = PutCompoundType<false, SortPolicy>(tData, cpdNode, szStackDepth - 1, funcInfo);
                        continue;
                    }
                }
                
                //是Compound但是需要再套一层或者不是Compound
                MYTRY;
                eRet = PutCompoundEntry<SortPolicy>(tData, MU8STR(""), tmpNode, szStackDepth - 1, funcInfo);
                MYCATCH;
                if (eRet != AllOk)
                {
                    STACK_TRACEBACK("PutCompoundEntry");
                    return eRet;
                }
 
                eRet = PutCompoundEnd(tData, funcInfo);
                if (eRet != AllOk)
                {
                    STACK_TRACEBACK("PutCompoundEnd");
                    return eRet;
                }
            }
        }
 
        return eRet;
    }
 
    template<typename SortPolicy, typename OutputStream, typename InfoFunc>
    static ErrCode PutSwitch(OutputStream &tData, const 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 = PutbuiltInType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Short:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Short>;
                eRet = PutbuiltInType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Int:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Int>;
                eRet = PutbuiltInType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Long:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Long>;
                eRet = PutbuiltInType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Float:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Float>;
                eRet = PutbuiltInType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::Double:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Double>;
                eRet = PutbuiltInType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::ByteArray:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::ByteArray>;
                eRet = PutArrayType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::String://类型唯一，非模板函数
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::String>;
                eRet = PutStringType(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::List://可能递归，需要处理szStackDepth
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::List>;
                eRet = PutListType<SortPolicy>(tData, nodeNbt.Get<CurType>(), szStackDepth, funcInfo);
            }
            break;
        case NBT_TAG::Compound://可能递归，需要处理szStackDepth
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::Compound>;
                eRet = PutCompoundType<false, SortPolicy>(tData, nodeNbt.Get<CurType>(), szStackDepth, funcInfo);
            }
            break;
        case NBT_TAG::IntArray:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::IntArray>;
                eRet = PutArrayType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::LongArray:
            {
                using CurType = NBT_Type::TagToType_T<NBT_TAG::LongArray>;
                eRet = PutArrayType<CurType>(tData, nodeNbt.Get<CurType>(), funcInfo);
            }
            break;
        case NBT_TAG::End://注意end标签绝对不可以进来
            {
                eRet = Error(NbtTypeTagError, tData, funcInfo, "{}:\nNBT Tag switch error: Unexpected Type Tag NBT_TAG::End[0x00(0)]", __FUNCTION__);
            }
            break;
        default://数据出错
            {
                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}({})] write error!",
                (NBT_TAG_RAW_TYPE)tagNbt, (NBT_TAG_RAW_TYPE)tagNbt);
        }
 
        return eRet;
    }
 
public:
    struct NoSortCompound
    {};

    template<bool bAscending = true>
    struct DefaultCompoundSort
    {
        std::vector<NBT_Type::Compound::Const_Iterator> operator()(const NBT_Type::Compound & cpdSort)
        {
            return cpdSort.KeySortIt<bAscending>();
        }
    };
 
 
    //输出到tData中，部分功能和原理参照ReadNBT处的注释，szDataStartIndex在此处可以对一个tData通过不同的tCompound和szStartIdx = tData.size()
    //来调用以达到把多个不同的nbt输出到同一个tData内的功能

    template<typename SortPolicy = DefaultCompoundSort<true>, typename OutputStream, typename InfoFunc = NBT_Print>
    static bool WriteNBT(OutputStream &OptStream, const NBT_Type::Compound &tCompound, size_t szStackDepth = 512, InfoFunc funcInfo = InfoFunc{}) noexcept
    {
        return PutCompoundType<true, SortPolicy>(OptStream, tCompound, szStackDepth, funcInfo) == AllOk;
    }

    template<typename SortPolicy = DefaultCompoundSort<true>, typename DataType = std::vector<uint8_t>, typename InfoFunc = NBT_Print>
    static bool WriteNBT(DataType &tDataOutput, size_t szStartIdx, const NBT_Type::Compound &tCompound, size_t szStackDepth = 512, InfoFunc funcInfo = InfoFunc{}) noexcept
    {
        NBT_IO::DefaultOutputStream<DataType> OptStream(tDataOutput, szStartIdx);
        return PutCompoundType<true, SortPolicy>(OptStream, tCompound, szStackDepth, funcInfo) == AllOk;
    }
 
#ifdef CJF2_NBT_CPP_USE_ZLIB

    template <typename InfoFunc = NBT_Print>
    static bool SimpleWriteNbtFile(const std::filesystem::path &pathFileName, const NBT_Type::Compound &tCompound, InfoFunc funcInfo = InfoFunc{}) noexcept
    {
        //写入文件
        std::vector<uint8_t> vNbtData;
        if (!WriteNBT(vNbtData, 0, tCompound, 512, funcInfo))
        {
            funcInfo(NBT_Print_Level::Err, "Error: WriteNBT failed.\n");
            return false;
        }
 
        //尝试压缩，压缩失败则直接写出
        std::vector<uint8_t> vFileData;
        if (!NBT_IO::CompressDataNoThrow(vFileData, vNbtData, -1, funcInfo))
        {
            funcInfo(NBT_Print_Level::Warn, "Warning: Compression failed, using uncompressed data.\n");
            vFileData = std::move(vNbtData);
        }
 
        //清理数据
        vNbtData.clear();
        vNbtData.shrink_to_fit();
 
        //写出
        if (!NBT_IO::WriteFile(pathFileName, vFileData, funcInfo))
        {
            funcInfo(NBT_Print_Level::Err, "Error: Cannot write file [{}].\n", pathFileName.string());
            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__
};