NBT_String.hpp

浏览该文件的文档.

#pragma once
 
#include <string>
#include <array>
#include <concepts>
 
#include "MUTF8_Tool.hpp"

 
class NBT_Reader;
class NBT_Writer;
class NBT_Helper;
 
template<typename String, typename StringView>
class NBT_String;

template<typename String, typename StringView>
class NBT_StringView : public StringView
{
    friend class NBT_Reader;
    friend class NBT_Writer;
    friend class NBT_Helper;
 
private:
    static constexpr typename StringView::size_type CalcStringViewSize(const typename StringView::value_type *ltrStr, typename StringView::size_type N)
    {
        //c string - 0x00
        if (N >= 1 && ltrStr[N - 1] == 0x00)
        {
            N -= 1;
        }
 
        //注意这里不返回，仍然要判断是否是mu8str
        //因为一个c风格字符串仍然可以以mu8str形式初始化
        //导致既包含末尾0也包含mu8结尾
 
        //mutf8 string - 0xC0 0x80
        if (N >= 2 && ltrStr[N - 1] == 0x80 && ltrStr[N - 2] == 0xC0)//这里仍然用N，因为前面可能已经递减，这样就能正确访问
        {
            N -= 2;
        }
 
        return N;
    }
 
public:
    using Super = StringView;

    using StringView::StringView;

    using StringView::operator=;

    constexpr NBT_StringView(const StringView &_Copy) :StringView(_Copy)
    {}

    constexpr NBT_StringView(StringView &&_Move) : StringView(std::move(_Move))
    {}

    template<typename StringView::size_type N>//c风格字符串or数组
    constexpr NBT_StringView(const typename StringView::value_type(&ltrStr)[N]) :StringView(ltrStr, CalcStringViewSize(ltrStr, N))
    {}

    constexpr explicit NBT_StringView(const NBT_String<String, StringView> &myString) : StringView(myString.data(), myString.size())
    {}

    NBT_StringView(NBT_String<String, StringView> &&_Temp) = delete;

    std::basic_string_view<char> GetCharTypeView(void) const noexcept
    {
        return std::basic_string_view<char>((const char *)StringView::data(), StringView::size());
    }

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

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

template<typename String, typename StringView>
class NBT_String :public String//暂时不考虑保护继承
{
    friend class NBT_Reader;
    friend class NBT_Writer;
    friend class NBT_Helper;
 
    static_assert(sizeof(char) == sizeof(typename String::value_type), "Size error");
    
private:
    static constexpr typename String::size_type CalcStringSize(const typename String::value_type *ltrStr, typename String::size_type N)
    {
        //c string - 0x00
        if (N >= 1 && ltrStr[N - 1] == 0x00)
        {
            N -= 1;
        }
 
        //注意这里不返回，仍然要判断是否是mu8str
        //因为一个c风格字符串仍然可以以mu8str形式初始化
        //导致既包含末尾0也包含mu8结尾
 
        //mutf8 string - 0xC0 0x80
        if (N >= 2 && ltrStr[N - 1] == 0x80 && ltrStr[N - 2] == 0xC0)//这里仍然用N，因为前面可能已经递减，这样就能正确访问
        {
            N -= 2;
        }
 
        return N;
    }
 
public:
    using Super = String;

    using View = NBT_StringView<String, StringView>;

    using String::String;

    using String::operator=;

    NBT_String(const String &_Copy) :String(_Copy)
    {}

    NBT_String(String &&_Move) :String(std::move(_Move))
    {}

    struct USE_RAW_DATA
    {};
 
 

    NBT_String(const std::basic_string<char> &u8CharTypeString, USE_RAW_DATA) :NBT_String(std::basic_string_view<char>(u8CharTypeString), USE_RAW_DATA{})
    {}

    NBT_String(const std::basic_string<char8_t> &u8String, USE_RAW_DATA) :NBT_String(std::basic_string_view<char8_t>(u8String), USE_RAW_DATA{})
    {}

    NBT_String(const std::basic_string<char> &u8CharTypeString) : NBT_String(std::basic_string_view<char>(u8CharTypeString))
    {}

    NBT_String(const std::basic_string<char8_t> &u8String) : NBT_String(std::basic_string_view<char8_t>(u8String))
    {}

    template<typename = void>
    requires(sizeof(wchar_t) == sizeof(char16_t))
    NBT_String(const std::basic_string<wchar_t> &u16WCharTypeString) :NBT_String(std::basic_string_view<wchar_t>(u16WCharTypeString))
    {}

    NBT_String(const std::basic_string<char16_t> &u16String) :NBT_String(std::basic_string_view<char16_t>(u16String))
    {}
 
 

    NBT_String(std::basic_string_view<char> u8CharTypeString, USE_RAW_DATA) :String((typename String::value_type *)u8CharTypeString.data(), u8CharTypeString.size())
    {}

    NBT_String(std::basic_string_view<char8_t> u8String, USE_RAW_DATA) :String((typename String::value_type *)u8String.data(), u8String.size())
    {}

    NBT_String(std::basic_string_view<char> u8CharTypeString) :String(MUTF8_Tool<typename String::value_type, char16_t, char>::U8ToMU8(u8CharTypeString))
    {}

    NBT_String(std::basic_string_view<char8_t> u8String) :String(MUTF8_Tool<typename String::value_type, char16_t, char8_t>::U8ToMU8(u8String))
    {}

    template<typename = void>
    requires(sizeof(wchar_t) == sizeof(char16_t))
    NBT_String(std::basic_string_view<wchar_t> u16WCharTypeString) :String(MUTF8_Tool<typename String::value_type, wchar_t, char8_t>::U16ToMU8(u16WCharTypeString))
    {}

    NBT_String(std::basic_string_view<char16_t> u16String) :String(MUTF8_Tool<typename String::value_type, char16_t, char8_t>::U16ToMU8(u16String))
    {}
 
 

    template<typename String::size_type N>
    NBT_String(const typename String::value_type(&ltrStr)[N]) :String(ltrStr, CalcStringSize(ltrStr, N))
    {}

    NBT_String(const View &view) :String(view)
    {}

    NBT_String(const StringView &_View) :String(_View)
    {}
 

    View GetView(void) const & noexcept
    {
        return View{ *this };
    }

    View GetView(void) const &&noexcept = delete;
 

    std::basic_string_view<char> GetCharTypeView(void) const & noexcept
    {
        return std::basic_string_view<char>((const char *)String::data(), String::size());
    }

    std::basic_string_view<char> GetCharTypeView(void) const &&noexcept = delete;
 
 

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

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

    auto ToCharTypeUTF8(void) const
    {
        return MUTF8_Tool<typename String::value_type, char16_t, char>::MU8ToU8(*this);//char8_t改为char
    }

    auto ToUTF8(void) const
    {
        return MUTF8_Tool<typename String::value_type, char16_t, char8_t>::MU8ToU8(*this);
    }

    template<typename = void>
    requires(sizeof(wchar_t) == sizeof(char16_t))
    auto ToWchartTypeUTF16(void) const
    {
        return MUTF8_Tool<typename String::value_type, wchar_t, char8_t>::MU8ToU16(*this);//char16_t改为wchar_t
    }

    auto ToUTF16(void) const
    {
        return MUTF8_Tool<typename String::value_type, char16_t, char8_t>::MU8ToU16(*this);
    }
 
 

    void FromCharTypeUTF8(const std::basic_string<char> &u8CharTypeString)
    {
        FromCharTypeUTF8(std::basic_string_view<char>(u8CharTypeString));
    }

    void FromCharTypeUTF8(const std::basic_string<char> &u8CharTypeString, USE_RAW_DATA)
    {
        FromCharTypeUTF8(std::basic_string_view<char>(u8CharTypeString), USE_RAW_DATA{});
    }

    void FromUTF8(const std::basic_string<char8_t> &u8String)
    {
        FromUTF8(std::basic_string_view<char8_t>(u8String));
    }

    void FromUTF8(const std::basic_string<char8_t> &u8String, USE_RAW_DATA)
    {
        FromUTF8(std::basic_string_view<char8_t>(u8String), USE_RAW_DATA{});
    }

    template<typename = void>
    requires(sizeof(wchar_t) == sizeof(char16_t))
    void FromWchartTypeUTF16(const std::basic_string<wchar_t> &u16WCharTypeString)
    {
        FromWchartTypeUTF16(std::basic_string_view<wchar_t>(u16WCharTypeString));
    }

    void FromUTF16(const std::basic_string<char16_t> &u16String)
    {
        FromUTF16(std::basic_string_view<char16_t>(u16String));
    }
 
 

    void FromCharTypeUTF8(std::basic_string_view<char> u8CharTypeString)
    {
        String::operator=(MUTF8_Tool<typename String::value_type, char16_t, char>::U8ToMU8(u8CharTypeString));//char8_t改为char
    }

    void FromCharTypeUTF8(std::basic_string_view<char> u8CharTypeString, USE_RAW_DATA)
    {
        String::operator=((typename String::value_type *)u8CharTypeString.data(), u8CharTypeString.size());
    }

    void FromUTF8(std::basic_string_view<char8_t> u8String)
    {
        String::operator=(MUTF8_Tool<typename String::value_type, char16_t, char8_t>::U8ToMU8(u8String));
    }

    void FromUTF8(std::basic_string_view<char8_t> u8String, USE_RAW_DATA)
    {
        String::operator=((typename String::value_type *)u8String.data(), u8String.size());
    }

    template<typename = void>
    requires(sizeof(wchar_t) == sizeof(char16_t))
    void FromWchartTypeUTF16(std::basic_string_view<wchar_t> u16WCharTypeString)
    {
        String::operator=(MUTF8_Tool<typename String::value_type, wchar_t, char8_t>::U16ToMU8(u16WCharTypeString));//char16_t改为wchar_t
    }

    void FromUTF16(std::basic_string_view<char16_t> u16String)
    {
        String::operator=(MUTF8_Tool<typename String::value_type, char16_t, char8_t>::U16ToMU8(u16String));
    }
};
 

namespace std
{
    template<typename String, typename StringView>
    struct hash<NBT_String<String, StringView>>
    {
        size_t operator()(const NBT_String<String, StringView> &s) const noexcept
        {
            return std::hash<std::basic_string_view<char>>{}(s.GetCharTypeView());
        }
    };

    template<typename String, typename StringView>
    struct hash<NBT_StringView<String, StringView>>
    {
        size_t operator()(const NBT_StringView<String, StringView> &s) const noexcept
        {
            return std::hash<std::basic_string_view<char>>{}(s.GetCharTypeView());
        }
    };
}

namespace NBT_String_Helper
{
 
    template <typename T>
    struct Is_NBT_String : std::false_type
    {};
 
    template <typename String, typename StringView>
    struct Is_NBT_String<NBT_String<String, StringView>> : std::true_type
    {};
 
    template <typename T>
    inline constexpr bool Is_NBT_String_V = Is_NBT_String<T>::value;
 
    template <typename T>
    struct Is_NBT_String_View : std::false_type
    {};
 
    template <typename String, typename StringView>
    struct Is_NBT_String_View<NBT_StringView<String, StringView>> : std::true_type
    {};
 
    template <typename T>
    inline constexpr bool Is_NBT_String_View_V = Is_NBT_String_View<T>::value;


    template <typename T>
    concept Is_NBT_String_Or_View =
        Is_NBT_String_V<std::remove_cvref_t<T>> ||
        Is_NBT_String_View_V<std::remove_cvref_t<T>>;
};

struct NBT_String_Transparent_Hash
{
    using is_transparent = void;

    template <typename T>
    requires (NBT_String_Helper::Is_NBT_String_Or_View<T>)
    std::size_t operator()(const T &s) const
    {
        return std::hash<std::basic_string_view<char>>{}(s.GetCharTypeView());
    }
};

struct NBT_String_Transparent_Equal
{
    using is_transparent = void;

    template <typename TL, typename TR>
    requires (
        NBT_String_Helper::Is_NBT_String_Or_View<TL> &&
        NBT_String_Helper::Is_NBT_String_Or_View<TR> &&
        std::equality_comparable_with<TL, TR>
    )
    bool operator()(const TL &l, const TR &r) const
    {
        return l == r;
    }
};