NBT_List.hpp

浏览该文件的文档.

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

 
class NBT_Reader;
class NBT_Writer;
class NBT_Helper;

template <typename List>
class NBT_List :protected List
{
    friend class NBT_Reader;
    friend class NBT_Writer;
    friend class NBT_Helper;
    
public:
    using Super = List;

    
    using Value_Type =              typename List::value_type;              
    using Allocator_Type =          typename List::allocator_type;          
    using Size_Type =               typename List::size_type;               
    using Difference_Type =         typename List::difference_type;         
    using Reference =               typename List::reference;               
    using Const_Reference =         typename List::const_reference;         
    using Pointer =                 typename List::pointer;                 
    using Const_Pointer =           typename List::const_pointer;           
    using Iterator =                typename List::iterator;                
    using Const_Iterator =          typename List::const_iterator;          
    using Reverse_Iterator =        typename List::reverse_iterator;        
    using Const_Reverse_Iterator =  typename List::const_reverse_iterator;  

 
public:
    //完美转发、初始化列表代理构造

    template<typename... Args>
    NBT_List(Args&&... args) : List(std::forward<Args>(args)...)
    {}

    NBT_List(std::initializer_list<typename List::value_type> init) : List(init)
    {}

    NBT_List(void) = default;
    ~NBT_List(void) = default;

    NBT_List(NBT_List &&_Move) noexcept :List(std::move(_Move))
    {}

    NBT_List(const NBT_List &_Copy) :List(_Copy)
    {}

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

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

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

    NBT_List &operator=(const NBT_List &_Copy)
    {
        List::operator=(_Copy);
        return *this;
    }

    bool operator==(const NBT_List &_Right) const noexcept
    {
        return (const List &)*this == (const List &)_Right;
    }

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

    std::partial_ordering operator<=>(const NBT_List &_Right) const noexcept
    {
        return (const List &)*this <=> (const List &)_Right;
    }

 
    using List::begin;
    using List::end;
    using List::cbegin;
    using List::cend;
    using List::rbegin;
    using List::rend;
    using List::crbegin;
    using List::crend;
    using List::operator[];



    typename List::value_type &Get(const typename List::size_type &szPos)
    {
        return List::at(szPos);
    }

    const typename List::value_type &Get(const typename List::size_type &szPos) const
    {
        return List::at(szPos);
    }

    typename List::value_type *Has(const typename List::size_type &szPos) noexcept
    {
        return szPos < List::size()
            ? &List::operator[](szPos)
            : nullptr;
    }

    const typename List::value_type *Has(const typename List::size_type &szPos) const noexcept
    {
        return szPos < List::size()
            ? &List::operator[](szPos)
            : nullptr;
    }

    typename List::value_type &Front(void) noexcept
    {
        return List::front();
    }

    const typename List::value_type &Front(void) const noexcept
    {
        return List::front();
    }

    typename List::value_type &Back(void) noexcept
    {
        return List::back();
    }

    const typename List::value_type &Back(void) const noexcept
    {
        return List::back();
    }


    
    template <typename V>
    typename List::value_type &Add(typename List::size_type szPos, V &&vTagVal)
    {
        return *List::emplace(List::begin() + szPos, std::forward<V>(vTagVal));//插入
    }

    template <typename V>
    typename List::value_type &AddFront(V &&vTagVal)
    {
        return *List::emplace(List::begin(), std::forward<V>(vTagVal));//插入
    }

    template <typename V>
    typename List::value_type &AddBack(V &&vTagVal)
    {
        return List::emplace_back(std::forward<V>(vTagVal));
    }

    template <typename V>
    typename List::value_type &Set(typename List::size_type szPos, V &&vTagVal)
    {
        return List::operator[](szPos) = std::forward<V>(vTagVal);
    }

    void Remove(typename List::size_type szPos)
    {
        List::erase(List::begin() + szPos);//这个没必要返回结果，直接丢弃
    }

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

    void Resize(typename List::size_type szNewSize)
    {
        return List::resize(szNewSize);
    }

    void Resize(typename List::size_type szNewSize, const typename List::value_type &value)
    {
        return List::resize(szNewSize, value);
    }

    void Merge(const NBT_List &_Copy)
    {
        List::insert(List::end(), _Copy.begin(), _Copy.end());
    }

    void Merge(NBT_List &&_Move)
    {
        List::insert(List::end(), std::make_move_iterator(_Move.begin()), std::make_move_iterator(_Move.end()));
    }

    typename List::iterator Insert(typename List::const_iterator itPos, const typename List::value_type &value)
    {
        return List::insert(itPos, value);
    }

    typename List::iterator Insert(typename List::const_iterator itPos, typename List::value_type &&value)
    {
        return List::insert(itPos, std::move(value));
    }

    typename List::iterator Insert(typename List::const_iterator itPos, typename List::size_type szCount, const typename List::value_type &value)
    {
        return List::insert(itPos, szCount, value);
    }

    template<typename InputIt>
    typename List::iterator Insert(typename List::const_iterator itPos, InputIt itFirst, InputIt itLast)
    {
        return List::insert(itPos, itFirst, itLast);
    }

    typename List::iterator Insert(typename List::const_iterator itPos, std::initializer_list<typename List::value_type> ilistValue)
    {
        return List::insert(itPos, ilistValue);
    }


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

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

    void Reserve(typename List::size_type szNewCap)
    {
        return List::reserve(szNewCap);
    }

    void ShrinkToFit(void)
    {
        return List::shrink_to_fit();
    }

    bool Contains(const typename List::value_type &tValue) const noexcept
    {
        return std::find(List::begin(), List::end(), tValue) != List::end();
    }

    template<typename Predicate>
    bool ContainsIf(Predicate pred) const noexcept
    {
        return std::find_if(List::begin(), List::end(), pred) != List::end();
    }

#define TYPE_GET_FUNC(type)\
\
const typename NBT_Type::type &Get##type(const typename List::size_type &szPos) const\
{\
    return List::at(szPos).Get##type();\
}\
\
\
typename NBT_Type::type &Get##type(const typename List::size_type &szPos)\
{\
    return List::at(szPos).Get##type();\
}\
\
\
const typename NBT_Type::type *Has##type(const typename List::size_type &szPos) const noexcept\
{\
    auto *p = Has(szPos);\
    return p != nullptr\
        ? p->GetIf##type()\
        : nullptr;\
}\
\
\
typename NBT_Type::type *Has##type(const typename List::size_type &szPos) noexcept\
{\
    auto *p = Has(szPos);\
    return p != nullptr\
        ? p->GetIf##type()\
        : nullptr;\
}\
\
\
const typename NBT_Type::type &Front##type(void) const\
{\
    return List::front().Get##type();\
}\
\
\
typename NBT_Type::type &Front##type(void)\
{\
    return List::front().Get##type();\
}\
\
\
const typename NBT_Type::type *FrontIf##type(void) const\
{\
    return List::front().GetIf##type();\
}\
\
\
typename NBT_Type::type *FrontIf##type(void)\
{\
    return List::front().GetIf##type();\
}\
\
\
const typename NBT_Type::type &Back##type(void) const\
{\
    return List::back().Get##type();\
}\
\

 */\
typename NBT_Type::type &Back##type(void)\
{\
    return List::back().Get##type();\
}\
\
\
const typename NBT_Type::type *BackIf##type(void) const\
{\
    return List::back().GetIf##type();\
}\
\
\
typename NBT_Type::type *BackIf##type(void)\
{\
    return List::back().GetIf##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_PUT_FUNC(type)\
\
typename List::value_type &Add##type(typename List::size_type szPos, const typename NBT_Type::type &vTagVal)\
{\
    return Add(szPos, vTagVal);\
}\
\
\
typename List::value_type & Add##type(typename List::size_type szPos, typename NBT_Type::type &&vTagVal)\
{\
    return Add(szPos, std::move(vTagVal));\
}\
\
\
typename List::value_type &AddFront##type(const typename NBT_Type::type &vTagVal)\
{\
    return AddFront(vTagVal); \
}\
\
\
typename List::value_type & AddFront##type(typename NBT_Type::type &&vTagVal)\
{\
    return AddFront(std::move(vTagVal));\
}\
\
\
typename List::value_type &AddBack##type(const typename NBT_Type::type &vTagVal)\
{\
    return AddBack(vTagVal);\
}\
\
\
typename List::value_type &AddBack##type(typename NBT_Type::type &&vTagVal)\
{\
    return AddBack(std::move(vTagVal));\
}\
\
\
typename List::value_type &Set##type(typename List::size_type szPos, const typename NBT_Type::type &vTagVal)\
{\
    return Set(szPos, vTagVal);\
}\
\
\
typename List::value_type &Set##type(typename List::size_type szPos, typename NBT_Type::type &&vTagVal)\
{\
    return Set(szPos, 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
};