utf.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_UTF_HPP__
#define NEFORCE_CORE_STRING_UTF_HPP__

 
#include "NeForce/core/interface/icharacter.hpp"
#include "NeForce/core/string/codepoint.hpp"
NEFORCE_BEGIN_NAMESPACE__



struct character : icharacter<character, char> {
    using value_type = char;                  
    using base = icharacter<character, char>; 
 
    constexpr character() noexcept = default;
    NEFORCE_CONSTEXPR20 ~character() = default;
 
    constexpr character(const character&) noexcept = default;
    constexpr character(character&&) noexcept = default;
 
    constexpr character& operator=(const character& other) noexcept = default;
    constexpr character& operator=(character&& other) noexcept = default;
 
    explicit constexpr character(const value_type value) noexcept :
    base(value) {}
 
    constexpr character& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    static NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<value_type>& obj) { return string{obj}; }

    static NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        wstring result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }
 
#if defined(NEFORCE_STANDARD_20) || defined(NEXUSFORCE_ENABLE_DOXYGEN)
    static NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u8string result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }
#endif

    static NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u16string result;
        result.reserve(obj.size() * 2);
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u32string result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }
};
 
template <>
struct package<char> {
    using type = character;
};
 
template <>
struct unpackage<character> {
    using type = char;
};

struct wcharacter : icharacter<wcharacter, wchar_t> {
    using value_type = wchar_t;                   
    using base = icharacter<wcharacter, wchar_t>; 
 
    constexpr wcharacter() noexcept = default;
    NEFORCE_CONSTEXPR20 ~wcharacter() = default;
 
    constexpr wcharacter(const wcharacter&) noexcept = default;
    constexpr wcharacter(wcharacter&&) noexcept = default;
 
    constexpr wcharacter& operator=(const wcharacter& other) noexcept = default;
    constexpr wcharacter& operator=(wcharacter&& other) noexcept = default;
 
    explicit constexpr wcharacter(const value_type value) noexcept :
    base(value) {}
 
    constexpr wcharacter& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    static NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        string result;
 
#ifdef NEFORCE_PLATFORM_WINDOWS
        size_t i = 0;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), false).append_to(result);
        }
#else
        for (const value_type c: obj) {
            codepoint(static_cast<uint32_t>(c)).append_to(result);
        }
#endif
        return result;
    }

    static NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<value_type>& obj) { return wstring{obj}; }
 
#if defined(NEFORCE_STANDARD_20) || defined(NEXUSFORCE_ENABLE_DOXYGEN)
    static NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u8string result;
 
#    ifdef NEFORCE_PLATFORM_WINDOWS
        size_t i = 0;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), false).append_to(result);
        }
#    else
        for (const value_type c: obj) {
            codepoint(static_cast<uint32_t>(c)).append_to(result);
        }
#    endif
        return result;
    }
#endif

    static NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u16string result;
 
#ifdef NEFORCE_PLATFORM_WINDOWS
        result.reserve(obj.size());
        for (size_t i = 0; i < obj.size(); ++i) {
            result.push_back(static_cast<char16_t>(static_cast<uint16_t>(obj[i])));
        }
#else
        result.reserve(obj.size() * 2);
        for (const value_type c: obj) {
            codepoint(static_cast<uint32_t>(c)).append_to(result);
        }
#endif
        return result;
    }

    static NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u32string result;
        result.reserve(obj.size());
 
#ifdef NEFORCE_PLATFORM_WINDOWS
        size_t i = 0;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), false).append_to(result);
        }
#else
        for (const value_type c: obj) {
            codepoint(static_cast<uint32_t>(c)).append_to(result);
        }
#endif
        return result;
    }
};
 
template <>
struct package<wchar_t> {
    using type = wcharacter;
};
 
template <>
struct unpackage<wcharacter> {
    using type = wchar_t;
};
 
 
#if defined(NEFORCE_STANDARD_20) || defined(NEXUSFORCE_ENABLE_DOXYGEN)

struct u8character : icharacter<u8character, char8_t> {
    using value_type = char8_t;                    
    using base = icharacter<u8character, char8_t>; 
 
    constexpr u8character() noexcept = default;
    NEFORCE_CONSTEXPR20 ~u8character() = default;
 
    constexpr u8character(const u8character&) noexcept = default;
    constexpr u8character(u8character&&) noexcept = default;
 
    constexpr u8character& operator=(const u8character& other) noexcept = default;
    constexpr u8character& operator=(u8character&& other) noexcept = default;
 
    explicit constexpr u8character(const value_type value) noexcept :
    base(value) {}
 
    constexpr u8character& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    static NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        string result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        wstring result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<value_type>& obj) { return u8string{obj}; }

    static NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u16string result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u32string result;
        result.reserve(obj.size());
 
        const auto* data = reinterpret_cast<const byte_t*>(obj.data());
        size_t i = 0;
        const size_t len = obj.size();
 
        while (i < len) {
            codepoint::decode_utf8(data, i, len).append_to(result);
        }
        return result;
    }
};
 
template <>
struct package<char8_t> {
    using type = u8character;
};
 
template <>
struct unpackage<u8character> {
    using type = char8_t;
};
 
#endif

struct u16character : icharacter<u16character, char16_t> {
public:
    using value_type = char16_t;                     
    using base = icharacter<u16character, char16_t>; 
 
private:
    template <typename T>
    static void parse_utf16_bom(const basic_string_view<T>& obj, size_t& start_pos, bool& need_swap) noexcept {
        start_pos = 0;
        need_swap = false;
 
        if (obj.empty()) {
            return;
        }
 
        if (static_cast<uint16_t>(obj[0]) == 0xFEFF) {
            start_pos = 1;
            need_swap = endian::is_big_endian;
        } else if (static_cast<uint16_t>(obj[0]) == 0xFFFE) {
            start_pos = 1;
            need_swap = endian::is_little_endian;
        }
    }
 
public:
    constexpr u16character() noexcept = default;
    NEFORCE_CONSTEXPR20 ~u16character() = default;
 
    constexpr u16character(const u16character&) noexcept = default;
    constexpr u16character(u16character&&) noexcept = default;
 
    constexpr u16character& operator=(const u16character& other) noexcept = default;
    constexpr u16character& operator=(u16character&& other) noexcept = default;
 
    explicit constexpr u16character(const value_type value) noexcept :
    base(value) {}
 
    constexpr u16character& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    static NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        string result;
 
        size_t start_pos;
        bool need_swap;
        parse_utf16_bom(obj, start_pos, need_swap);
 
        size_t i = start_pos;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), need_swap).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        wstring result;
        result.reserve(obj.size());
 
        size_t start_pos;
        bool need_swap;
        parse_utf16_bom(obj, start_pos, need_swap);
 
        size_t i = start_pos;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), need_swap).append_to(result);
        }
        return result;
    }
 
#if defined(NEFORCE_STANDARD_20) || defined(NEXUSFORCE_ENABLE_DOXYGEN)
    static NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u8string result;
        result.reserve(obj.size() * 3);
 
        size_t start_pos;
        bool need_swap;
        parse_utf16_bom(obj, start_pos, need_swap);
 
        size_t i = start_pos;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), need_swap).append_to(result);
        }
        return result;
    }
#endif

    static NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
 
        size_t start_pos;
        bool need_swap;
        parse_utf16_bom(obj, start_pos, need_swap);
 
        if (start_pos == 0 && !need_swap) {
            return u16string{obj};
        }
 
        u16string result;
        result.reserve(obj.size());
 
        size_t i = start_pos;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), need_swap).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u32string result;
        result.reserve(obj.size());
 
        size_t start_pos;
        bool need_swap;
        parse_utf16_bom(obj, start_pos, need_swap);
 
        size_t i = start_pos;
        while (i < obj.size()) {
            codepoint::decode_utf16(obj.data(), i, obj.size(), need_swap).append_to(result);
        }
        return result;
    }
};
 
template <>
struct package<char16_t> {
    using type = u16character;
};
 
template <>
struct unpackage<u16character> {
    using type = char16_t;
};

struct u32character : icharacter<u32character, char32_t> {
    using value_type = char32_t;                     
    using base = icharacter<u32character, char32_t>; 
 
    constexpr u32character() noexcept = default;
    NEFORCE_CONSTEXPR20 ~u32character() = default;
 
    constexpr u32character(const u32character&) noexcept = default;
    constexpr u32character(u32character&&) noexcept = default;
 
    constexpr u32character& operator=(const u32character& other) noexcept = default;
    constexpr u32character& operator=(u32character&& other) noexcept = default;
 
    explicit constexpr u32character(const value_type value) noexcept :
    base(value) {}
 
    constexpr u32character& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    static NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        string result;
        for (const value_type c: obj) {
            codepoint::from_utf32(c).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        wstring result;
        result.reserve(obj.size());
        for (const value_type c: obj) {
            codepoint::from_utf32(c).append_to(result);
        }
        return result;
    }
 
#if defined(NEFORCE_STANDARD_20) || defined(NEXUSFORCE_ENABLE_DOXYGEN)
    static NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u8string result;
        result.reserve(obj.size() * 4);
        for (const value_type c: obj) {
            codepoint::from_utf32(c).append_to(result);
        }
        return result;
    }
#endif

    static NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<value_type>& obj) {
        if (obj.empty()) {
            return {};
        }
        u16string result;
        result.reserve(obj.size() * 2);
        for (const value_type c: obj) {
            codepoint::from_utf32(c).append_to(result);
        }
        return result;
    }

    static NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<value_type>& obj) {
        return u32string{obj};
    }
};
 
template <>
struct package<char32_t> {
    using type = u32character;
};
 
template <>
struct unpackage<u32character> {
    using type = char32_t;
};
 // UTF
 // Packages
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_UTF_HPP__