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;

template<typename Compound>
class NBT_Compound :protected Compound//Compound is Map
{
    friend class NBT_Reader;
    friend class NBT_Writer;
    friend class NBT_Helper;
 
public:
 
    using Hasher =                  typename Compound::hasher;                  
    using Key_Type =                typename Compound::key_type;                
    using Mapped_Type =             typename Compound::mapped_type;             
    using Key_Equal =               typename Compound::key_equal;               
    using Value_Type =              typename Compound::value_type;              
    using Allocator_Type =          typename Compound::allocator_type;          
    using Size_Type =               typename Compound::size_type;               
    using Difference_Type =         typename Compound::difference_type;         
    using Pointer =                 typename Compound::pointer;                 
    using Const_Pointer =           typename Compound::const_pointer;           
    using Reference =               typename Compound::reference;               
    using Const_Reference =         typename Compound::const_reference;         
    using Iterator =                typename Compound::iterator;                
    using Const_Iterator =          typename Compound::const_iterator;          
    using Local_Iterator =          typename Compound::local_iterator;          
    using Const_Local_Iterator =    typename Compound::const_local_iterator;    
    using Node_Type =               typename Compound::node_type;               
    using Insert_Return_Type =      typename Compound::insert_return_type;      

 
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) :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 (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;
    }

    template<bool bAscending = true>
    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
            {
                if constexpr (bAscending)
                {
                    return l->first < r->first;
                }
                else
                {
                    return l->first > r->first;
                }
            }
        );
 
        return listSortIt;
    }

    template<bool bAscending = true>
    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
            {
                if constexpr (bAscending)
                {
                    return l->first < r->first;
                }
                else
                {
                    return l->first > r->first;
                }
            }
        );
 
        return listSortIt;
    }

 
    using Compound::begin;
    using Compound::end;
    using Compound::cbegin;
    using Compound::cend;
    using Compound::operator[];

 
    //简化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)
    {
        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)
    {
        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
};