NBT_Node_View.hpp

浏览该文件的文档.

#pragma once
 
#include "NBT_Node.hpp"

 
//用法和NBT_Node一致，但是只持有构造时传入对象的指针，且不持有对象
//对象随时可销毁，如果销毁后使用持有销毁对象的view则行为未定义，用户自行负责
//构造传入nullptr指针且进行使用则后果自负

template <bool bIsConst>
class NBT_Node_View
{
    template <bool _bIsConst>
    friend class NBT_Node_View;//需要设置自己为友元，这样不同模板的类实例之间才能相互访问
 
public:
    //类型列表展开，声明std::variant
    template <typename T>
    struct AddConstIf
    {
        using type = std::conditional<bIsConst, const T, T>::type;
    };
 
    template <typename T>
    using PtrType = typename AddConstIf<T>::type *;
 
    template <typename T>
    struct TypeListPointerToVariant;
 
    template <typename... Ts>
    struct TypeListPointerToVariant<NBT_Type::_TypeList<Ts...>>
    {
        using type = std::variant<PtrType<Ts>...>;//展开成指针类型
    };

    using VariantData = TypeListPointerToVariant<NBT_Type::TypeList>::type;
 
protected:
    VariantData data;
 
public:
    static inline constexpr bool is_const = bIsConst;

    template <typename T>
    requires(!std::is_same_v<std::decay_t<T>, NBT_Node> &&NBT_Type::IsValidType_V<std::decay_t<T>> && !bIsConst)
    NBT_Node_View(T &value) : data(&value)
    {}

    template <typename T>
    requires(!std::is_same_v<std::decay_t<T>, NBT_Node> && NBT_Type::IsValidType_V<std::decay_t<T>> && bIsConst)
    NBT_Node_View(const T &value) : data(&value)
    {}

    NBT_Node_View(NBT_Node &node)
    {
        std::visit([this](auto &arg)
            {
                this->data = &arg;
            }, node.data);
    }

    template <typename = void>//requires占位模板
    requires(bIsConst)//此构造只在const的情况下生效，因为非const的情况下不能通过const对象初始化非const指针
    NBT_Node_View(const NBT_Node &node)
    {
        std::visit([this](auto &arg)
            {
                this->data = &arg;
            }, node.data);
    }

    template <typename = void>//requires占位模板
    requires(bIsConst)//此构造只在const的情况下生效，不能从const视图转换到非const视图
    NBT_Node_View(const NBT_Node_View<false> &_Other)
    {
        std::visit([this](auto &arg)
            {
                this->data = arg;//此处arg为非const指针
            }, _Other.data);
    }

    template <typename T>
    requires(!std::is_lvalue_reference_v<T>)
    NBT_Node_View(T &&_Temp) = delete;

    template <typename T>
    requires(!std::is_same_v<std::decay_t<T>, NBT_Node> && NBT_Type::IsValidType_V<std::decay_t<T>> && !bIsConst)
    T &Set(T &value)
    {
        data.template emplace<PtrType<T>>(&value);
        return value;
    }

    template <typename T>
    requires(!std::is_same_v<std::decay_t<T>, NBT_Node> && NBT_Type::IsValidType_V<std::decay_t<T>> && bIsConst)
    const T &Set(const T &value)
    {
        data.template emplace<PtrType<T>>(&value);
        return value;
    }

    template <typename = void>//requires占位模板
    requires(!bIsConst)
    NBT_Node &Set(NBT_Node &node)
    {
        std::visit([this](auto &arg)
            {
                this->data = &arg;
            }, node.data);
 
        return node;
    }

    template <typename = void>//requires占位模板
    requires(bIsConst)
    const NBT_Node &Set(const NBT_Node &node)
    {
        std::visit([this](auto &arg)
            {
                this->data = &arg;
            }, node.data);
 
        return node;
    }

    template <typename T>
    requires(!std::is_lvalue_reference_v<T>)
    T &Set(T &&_Temp) = delete;

    template <typename T>
    requires(!std::is_same_v<std::decay_t<T>, NBT_Node> && NBT_Type::IsValidType_V<std::decay_t<T>> && !bIsConst)
    NBT_Node_View &operator=(T &value)
    {
        data = &value;
 
        return *this;
    }

    template <typename T>
    requires(!std::is_same_v<std::decay_t<T>, NBT_Node> && NBT_Type::IsValidType_V<std::decay_t<T>> && bIsConst)
    NBT_Node_View &operator=(const T &value)
    {
        data = &value;
 
        return *this;
    }

    template <typename = void>
    requires(!bIsConst)
    NBT_Node_View &operator=(NBT_Node &node)
    {
        std::visit([this](auto &arg)
            {
                this->data = &arg;
            }, node.data);
 
        return *this;
    }

    template <typename = void>
    requires(bIsConst)
    NBT_Node_View &operator=(const NBT_Node &node)
    {
        std::visit([this](auto &arg)
            {
                this->data = &arg;
            }, node.data);
 
        return *this;
    }

    template <typename T>
    requires(!std::is_lvalue_reference_v<T>)
    NBT_Node_View &operator=(T &&_Temp) = delete;
 
public:
    NBT_Node_View() : data(PtrType<NBT_Type::End>{})
    {}

    ~NBT_Node_View() = default;

    NBT_Node_View(const NBT_Node_View &_Copy) : data(_Copy.data)
    {}

    NBT_Node_View(NBT_Node_View &&_Move) noexcept : data(std::move(_Move.data))
    {}

    const VariantData &GetData(void) const noexcept
    {
        return data;
    }

    VariantData &GetData(void) noexcept
    {
        return data;
    }

    NBT_Node_View &operator=(const NBT_Node_View &_Copy)
    {
        data = _Copy.data;
        return *this;
    }

    NBT_Node_View &operator=(NBT_Node_View &&_Move) noexcept
    {
        data = std::move(_Move.data);
        return *this;
    }

    bool operator==(const NBT_Node_View &_Right) const noexcept
    {
        if (GetTag() != _Right.GetTag())
        {
            return false;
        }
 
        return std::visit([this](const auto *argL, const auto *argR)-> bool
            {
                using TL = const std::decay_t<decltype(argL)>;
                return *argL == *(TL)argR;
            }, this->data, _Right.data);
    }

    bool operator!=(const NBT_Node_View &_Right) const noexcept
    {
        if (GetTag() != _Right.GetTag())
        {
            return true;
        }
 
        return std::visit([this](const auto *argL, const auto *argR)-> bool
            {
                using TL = const std::decay_t<decltype(argL)>;
                return *argL != *(TL)argR;
            }, this->data, _Right.data);
    }

    std::partial_ordering operator<=>(const NBT_Node_View &_Right) const noexcept
    {
        if (GetTag() != _Right.GetTag())
        {
            return std::partial_ordering::unordered;
        }
 
        return std::visit([this](const auto *argL, const auto *argR)-> std::partial_ordering
            {
                using TL = const std::decay_t<decltype(argL)>;
                return *argL <=> *(TL)argR;
            }, this->data, _Right.data);
    }

    NBT_TAG GetTag() const noexcept
    {
        return (NBT_TAG)data.index();//返回当前存储类型的index（0基索引，与NBT_TAG enum一一对应）
    }

    template<typename T>
    std::conditional_t<bIsConst, const T &, T &> Get() const
    {
        return *std::get<PtrType<T>>(data);
    }

    template<typename T>
    std::conditional_t<bIsConst, const T &, T &> Get()
    {
        return *std::get<PtrType<T>>(data);
    }

    template<typename T>
    std::conditional_t<bIsConst, const T *, T *>GetIf() const noexcept
    {
        auto p = std::get_if<PtrType<T>>(&data);//二维指针
        return p != nullptr ? *p : nullptr;
    }

    template<typename T>
    std::conditional_t<bIsConst, const T *, T *>GetIf() noexcept
    {
        auto p = std::get_if<PtrType<T>>(&data);//二维指针
        return p != nullptr ? *p : nullptr;
    }

    template<typename T>
    bool TypeHolds() const
    {
        return std::holds_alternative<PtrType<T>>(data);
    }

    bool IsEmpty() const
    {
        return TypeHolds<NBT_Type::End>() &&
            std::get<PtrType<NBT_Type::End>>(data) == PtrType<NBT_Type::End>{};
    }

    void SetEmpty()
    {
        data.template emplace<PtrType<NBT_Type::End>>(PtrType<NBT_Type::End>{});
    }
 
//针对每种类型生成一个方便的函数
//通过宏定义批量生成

#define TYPE_GET_FUNC(type)\
\
std::conditional_t<bIsConst, const NBT_Type::type &, NBT_Type::type &> Get##type() const\
{\
    return *std::get<PtrType<NBT_Type::type>>(data);\
}\
\
\
std::conditional_t<bIsConst, const NBT_Type::type &, NBT_Type::type &> Get##type()\
{\
    return *std::get<PtrType<NBT_Type::type>>(data);\
}\
\
\
std::conditional_t<bIsConst, const NBT_Type::type *, NBT_Type::type *> GetIf##type() const noexcept\
{\
    auto p = std::get_if<PtrType<NBT_Type::type>>(&data);\
    return p != nullptr ? *p : nullptr;\
}\
\
\
std::conditional_t<bIsConst, const NBT_Type::type *, NBT_Type::type *> GetIf##type() noexcept\
{\
    auto p = std::get_if<PtrType<NBT_Type::type>>(&data); \
    return p != nullptr ? *p : nullptr; \
}\
\
\
bool Is##type() const\
{\
    return std::holds_alternative<PtrType<NBT_Type::type>>(data);\
}\
\
friend std::conditional_t<bIsConst, const NBT_Type::type &, NBT_Type::type &> Get##type(NBT_Node_View & node)\
{\
    return node.Get##type();\
}\
\
\
friend std::conditional_t<bIsConst, const NBT_Type::type &, NBT_Type::type &> Get##type(const NBT_Node_View & node)\
{\
    return node.Get##type();\
}\
\
\
friend std::conditional_t<bIsConst, const NBT_Type::type *, NBT_Type::type *> GetIf##type(NBT_Node_View & node) noexcept\
{\
    return node.GetIf##type();\
}\
\

 */\
friend std::conditional_t<bIsConst, const NBT_Type::type *, NBT_Type::type *> GetIf##type(const NBT_Node_View & node) noexcept\
{\
    return node.GetIf##type();\
}\
\
\
friend bool Is##type(const NBT_Node_View &node)\
{\
    return node.Is##type();\
}


 
    TYPE_GET_FUNC(End);
    TYPE_GET_FUNC(Byte);
    TYPE_GET_FUNC(Short);
    TYPE_GET_FUNC(Int);
    TYPE_GET_FUNC(Long);
    TYPE_GET_FUNC(Float);
    TYPE_GET_FUNC(Double);
    TYPE_GET_FUNC(ByteArray);
    TYPE_GET_FUNC(IntArray);
    TYPE_GET_FUNC(LongArray);
    TYPE_GET_FUNC(String);
    TYPE_GET_FUNC(List);
    TYPE_GET_FUNC(Compound);

 
#undef TYPE_GET_FUNC

#define TYPE_SET_FUNC(type)\
\
template <typename = void>\
requires(!bIsConst)\
NBT_Type::type &Set##type(NBT_Type::type &value)\
{\
    return Set<NBT_Type::type>(value); \
}\
\
\
template <typename = void>\
requires(bIsConst)\
const NBT_Type::type &Set##type(const NBT_Type::type &value)\
{\
    return Set<NBT_Type::type>(value); \
}\
\
\
NBT_Type::type &Set##type(NBT_Type::type &&_Temp) = delete;

    
    TYPE_SET_FUNC(End);
    TYPE_SET_FUNC(Byte);
    TYPE_SET_FUNC(Short);
    TYPE_SET_FUNC(Int);
    TYPE_SET_FUNC(Long);
    TYPE_SET_FUNC(Float);
    TYPE_SET_FUNC(Double);
    TYPE_SET_FUNC(ByteArray);
    TYPE_SET_FUNC(IntArray);
    TYPE_SET_FUNC(LongArray);
    TYPE_SET_FUNC(String);
    TYPE_SET_FUNC(List);
    TYPE_SET_FUNC(Compound);

 
#undef TYPE_SET_FUNC
};