NBT_Compound.hpp

浏览该文件的文档.

#pragma once
 
#include <vector>
#include <unordered_map>
#include <compare>
#include <type_traits>
#include <initializer_list>
 
#include "NBT_Type.hpp"

 
class NBT_Reader;
class NBT_Writer;
class NBT_Helper;

namespace NBT_Compound_Concept
{
    template <typename T>
    concept HasSpaceship = requires(const T & a, const T & b)
    {
        {
            a <=> b
        };
    };

    template <typename T>
    concept HasRBegin = requires(T t)
    {
        t.rbegin();
    };

    template <typename T>
    concept HasCRBegin = requires(T t)
    {
        t.crbegin();
    };

    template <typename T>
    concept HasREnd = requires(T t)
    {
        t.rend();
    };

    template <typename T>
    concept HasCREnd = requires(T t)
    {
        t.crend();
    };
}

template<typename Compound>
class NBT_Compound :protected Compound//Compound is Map
{
    friend class NBT_Reader;
    friend class NBT_Writer;
    friend class NBT_Helper;
 
private:
    //总是允许插入nbt end，但是在写出文件时会忽略end类型
    //template<typename V>
    //bool TestType(V vTagVal)
    //{
    //  if constexpr (std::is_same_v<std::decay_t<V>, Compound::mapped_type>)
    //  {
    //      return vTagVal.GetTag() != NBT_TAG::End;
    //  }
    //  else
    //  {
    //      return NBT_Type::TypeTag_V<std::decay_t<V>> != NBT_TAG::End;
    //  }
    //}
public:
    //完美转发、初始化列表代理构造

    template<typename... Args>
    NBT_Compound(Args&&... args) : Compound(std::forward<Args>(args)...)
    {}

    NBT_Compound(std::initializer_list<typename Compound::value_type> init) : Compound(init)
    {}

    NBT_Compound(void) = default;
    ~NBT_Compound(void) = default;

    NBT_Compound(NBT_Compound &&_Move) noexcept :Compound(std::move(_Move))
    {}

    NBT_Compound(const NBT_Compound &_Copy) noexcept :Compound(_Copy)
    {}

    NBT_Compound &operator=(NBT_Compound &&_Move) noexcept
    {
        Compound::operator=(std::move(_Move));
        return *this;
    }

    NBT_Compound &operator=(const NBT_Compound &_Copy)
    {
        Compound::operator=(_Copy);
        return *this;
    }

    const Compound &GetData(void) const noexcept
    {
        return *this;
    }

    bool operator==(const NBT_Compound &_Right) const noexcept
    {
        return (const Compound &)*this == (const Compound &)_Right;
    }

    bool operator!=(const NBT_Compound &_Right) const noexcept
    {
        return (const Compound &)*this != (const Compound &)_Right;
    }

    std::partial_ordering operator<=>(const NBT_Compound &_Right) const noexcept
    {
        if constexpr (NBT_Compound_Concept::HasSpaceship<Compound>)
        {
            return (const Compound &)*this <=> (const Compound &)_Right;
        }
        else
        {
            if (auto _cmpSize = Compound::size() <=> _Right.size(); _cmpSize != 0)
            {
                return _cmpSize;
            }
 
            //数量相等，比较数据的排序
            const auto _lSort = this->KeySortIt();
            const auto _rSort = _Right.KeySortIt();
            typename Compound::size_type _Size = Compound::size();
 
            for (typename Compound::size_type _i = 0; _i < _Size; ++_i)
            {
                const auto &_lIt = _lSort[_i];
                const auto &_rIt = _rSort[_i];
 
                //首先比较名称，如果不同则返回
                if (auto _cmpKey = _lIt->first <=> _rIt->first; _cmpKey != 0)
                {
                    return _cmpKey;
                }
 
                //然后比较值，如果不同则返回
                if (auto _cmpVal = _lIt->second <=> _rIt->second; _cmpVal != 0)
                {
                    return _cmpVal;
                }
            }
 
            //前面都没有返回，那么所有元素都相等
            return std::partial_ordering::equivalent;
        }
    }

    std::vector<typename Compound::iterator> KeySortIt(void)
    {
        std::vector<typename Compound::iterator> listSortIt;
        listSortIt.reserve(Compound::size());
        for (auto it = Compound::begin(); it != Compound::end(); ++it)
        {
            listSortIt.push_back(it);
        }
 
        std::sort(listSortIt.begin(), listSortIt.end(),
            [](const auto &l, const auto &r) -> bool
            {
                return l->first < r->first;
            }
        );
 
        return listSortIt;
    }

    std::vector<typename Compound::const_iterator> KeySortIt(void) const
    {
        std::vector<typename Compound::const_iterator> listSortIt;
        listSortIt.reserve(Compound::size());
        for (auto it = Compound::cbegin(); it != Compound::cend(); ++it)
        {
            listSortIt.push_back(it);
        }
 
        std::sort(listSortIt.begin(), listSortIt.end(),
            [](const auto &l, const auto &r) -> bool
            {
                return l->first < r->first;
            }
        );
 
        return listSortIt;
    }

 
    using Compound::begin;
    using Compound::end;
    using Compound::cbegin;
    using Compound::cend;
    using Compound::operator[];
 
    //因为父类不总是有下面内容，所以使用requires检查并暴露或舍弃
    //using Compound::rbegin;
    //using Compound::rend;
    //using Compound::crbegin;
    //using Compound::crend;
    
    //存在则映射
    //-------------------- rbegin --------------------
    auto rbegin() requires NBT_Compound_Concept::HasRBegin<Compound> {return Compound::rbegin();}
    auto rbegin() const requires NBT_Compound_Concept::HasRBegin<Compound> {return Compound::rbegin();}
    auto crbegin() const noexcept requires NBT_Compound_Concept::HasCRBegin<Compound> {return Compound::crbegin();}
    //-------------------- rend --------------------
    auto rend() requires NBT_Compound_Concept::HasREnd<Compound> {return Compound::rend();}
    auto rend() const requires NBT_Compound_Concept::HasREnd<Compound> {return Compound::rend();}
    auto crend() const noexcept requires NBT_Compound_Concept::HasCREnd<Compound> {return Compound::crend();}

 
    //简化map查询

    typename Compound::mapped_type &Get(const typename Compound::key_type &sTagName)
    {
        return Compound::at(sTagName);
    }

    const typename Compound::mapped_type &Get(const typename Compound::key_type &sTagName) const
    {
        return Compound::at(sTagName);
    }
 

    typename Compound::mapped_type *Has(const typename Compound::key_type &sTagName) noexcept
    {
        auto find = Compound::find(sTagName);
        return find == Compound::end()
            ? NULL
            : &(find->second);
    }

    const typename Compound::mapped_type *Has(const typename Compound::key_type &sTagName) const noexcept
    {
        auto find = Compound::find(sTagName);
        return find == Compound::end()
            ? NULL
            : &(find->second);
    }
 
    //简化map插入
    //使用完美转发，不丢失引用、右值信息

    template <typename K, typename V>
    requires std::constructible_from<typename Compound::key_type, K &&> &&std::constructible_from<typename Compound::mapped_type, V &&>
    std::pair<typename Compound::iterator, bool> Put(K &&sTagName, V &&vTagVal)
    {
        //总是允许插入nbt end，但是在写出文件时会忽略end类型
        //if (!TestType(vTagVal))
        //{
        //  return std::pair{ Compound::end(),false };
        //}
 
        return Compound::insert_or_assign(std::forward<K>(sTagName), std::forward<V>(vTagVal));
    }

    template <typename K, typename V>
    requires std::constructible_from<typename Compound::key_type, K &&> &&std::constructible_from<typename Compound::mapped_type, V &&>
    std::pair<typename Compound::iterator, bool> TryPut(K &&sTagName, V &&vTagVal)
    {
        //总是允许插入nbt end，但是在写出文件时会忽略end类型
        //if (!TestType(vTagVal))
        //{
        //  return std::pair{ Compound::end(),false };
        //}
 
        return Compound::try_emplace(std::forward<K>(sTagName), std::forward<V>(vTagVal));
    }

    bool Remove(const typename Compound::key_type &sTagName)
    {
        return Compound::erase(sTagName) != 0;//返回1即为成功，否则为0，标准库：返回值为删除的元素数（0 或 1）。
    }

    void Clear(void)
    {
        Compound::clear();
    }

    bool Empty(void) const noexcept
    {
        return Compound::empty();
    }

    typename Compound::size_type Size(void) const noexcept
    {
        return Compound::size();
    }

    void Merge(const NBT_Compound &_Copy)
    {
        Compound::merge(_Copy);
    }

    void Merge(NBT_Compound &&_Move)
    {
        Compound::merge(std::move(_Move));
    }

    bool Contains(const typename Compound::key_type &sTagName) const noexcept
    {
        return Compound::contains(sTagName);
    }

    template<typename Predicate>
    bool ContainsIf(Predicate pred) const noexcept
    {
        return std::find_if(Compound::begin(), Compound::end(), pred) != Compound::end();
    }
 
 
//针对每种类型生成一个方便的函数
//通过宏定义批量生成

#define TYPE_GET_FUNC(type)\
\
bool Contains##type(const typename Compound::key_type &sTagName) const\
{\
    auto *p = Has(sTagName);\
    return p != NULL && p->GetTag() == NBT_TAG::type;\
}\
\
\
const typename NBT_Type::type &Get##type(const typename Compound::key_type & sTagName) const\
{\
    return Compound::at(sTagName).Get##type();\
}\
\
\
typename NBT_Type::type &Get##type(const typename Compound::key_type & sTagName)\
{\
    return Compound::at(sTagName).Get##type();\
}\
\
\
const typename NBT_Type::type *Has##type(const typename Compound::key_type & sTagName) const noexcept\
{\
    auto *p = Has(sTagName);\
    return p != NULL && p->Is##type()\
        ? &(p->Get##type())\
        : NULL;\
}\
\
\
typename NBT_Type::type *Has##type(const typename Compound::key_type & sTagName) noexcept\
{\
    auto *p = Has(sTagName);\
    return p != NULL && p->Is##type()\
        ? &(p->Get##type())\
        : NULL;\
}

    /// @name 针对每种类型提供一个方便使用的函数，由宏批量生成
    /// @brief 具体作用说明：
    /// - Get开头+类型名的函数：直接获取指定标签名且对应类型的引用，异常由std::unordered_map的at与std::get具体实现决定
    /// - Has开头 + 类型名的函数：判断指定标签名是否存在，且标签名对应的类型是否是指定类型，都符合则返回对应指针，否则返回NULL指针
    /// @{
 
    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_PUT_FUNC(type)\

\
template <typename K>\
requires std::constructible_from<typename Compound::key_type, K &&>\
std::pair<typename Compound::iterator, bool> Put##type(K &&sTagName, const typename NBT_Type::type &vTagVal)\
{\
    return Put(std::forward<K>(sTagName), vTagVal);\
}\
\
\
template <typename K>\
requires std::constructible_from<typename Compound::key_type, K &&>\
std::pair<typename Compound::iterator, bool> Put##type(K &&sTagName, typename NBT_Type::type &&vTagVal)\
{\
    return Put(std::forward<K>(sTagName), std::move(vTagVal));\
}\
\
\
template <typename K>\
requires std::constructible_from<typename Compound::key_type, K &&>\
std::pair<typename Compound::iterator, bool> TryPut##type(K &&sTagName, const typename NBT_Type::type &vTagVal)\
{\
    return TryPut(std::forward<K>(sTagName), vTagVal);\
}\
\
\
template <typename K>\
requires std::constructible_from<typename Compound::key_type, K &&>\
std::pair<typename Compound::iterator, bool> TryPut##type(K &&sTagName, typename NBT_Type::type &&vTagVal)\
{\
    return TryPut(std::forward<K>(sTagName), std::move(vTagVal));\
}

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

 
#undef TYPE_PUT_FUNC
};