codepoint.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_CODEPOINT_HPP__
#define NEFORCE_CORE_STRING_CODEPOINT_HPP__

 
#include "NeForce/core/memory/endian.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API codepoint {
public:
    static constexpr uint32_t REPLACEMENT_VALUE = 0xFFFD;
    static constexpr uint32_t MAX_VALUE = 0x10FFFF;

    NEFORCE_CONST_FUNCTION static constexpr bool is_high_surrogate(const char16_t c) noexcept {
        return c >= 0xD800 && c <= 0xDBFF;
    }

    NEFORCE_CONST_FUNCTION static constexpr bool is_low_surrogate(const char16_t c) noexcept {
        return c >= 0xDC00 && c <= 0xDFFF;
    }

    NEFORCE_CONST_FUNCTION static constexpr codepoint combine_surrogates(const char16_t high,
                                                                         const char16_t low) noexcept {
        return codepoint{0x10000 + ((static_cast<uint32_t>(high) - 0xD800) << 10) +
                         (static_cast<uint32_t>(low) - 0xDC00)};
    }

    static constexpr bool is_valid_codepoint(const uint32_t v) noexcept {
        return v <= MAX_VALUE && !is_high_surrogate(v) && !is_low_surrogate(v);
    }

    static constexpr codepoint replacement() noexcept {
        codepoint cp;
        cp.value_ = REPLACEMENT_VALUE;
        return cp;
    }

    static constexpr codepoint null() noexcept { return codepoint(0u); }

    static codepoint decode_utf8(const byte_t* data, size_t& i, size_t len) noexcept;

    template <typename T>
    static codepoint decode_utf16(const T* data, size_t& index, const size_t len, const bool need_swap) noexcept {
        uint32_t cp;
        size_t consumed;
        const bool ok = codepoint::utf16_codepoint(data, index, len, cp, consumed, need_swap);
        if (consumed == 0) {
            return replacement();
        }
        index += consumed;
        return ok ? codepoint(cp) : replacement();
    }

    static constexpr codepoint from_utf32(char32_t value) noexcept { return codepoint(static_cast<uint32_t>(value)); }
 
private:
    uint32_t value_; 
 
private:
    template <typename T>
    static bool utf16_codepoint(const T* data, size_t index, const size_t len, uint32_t& cp, size_t& consumed,
                                const bool need_swap) {
        if (index >= len) {
            cp = 0xFFFD;
            consumed = 0;
            return false;
        }
 
        const auto raw1 = static_cast<uint16_t>(data[index]);
        const auto c1 = static_cast<uint32_t>(need_swap ? endian::byteswap16(raw1) : raw1);
        consumed = 1;
 
        if (is_high_surrogate(c1)) {
            if (index + 1 < len) {
                const auto raw2 = static_cast<uint16_t>(data[index + 1]);
                const auto c2 = static_cast<uint32_t>(need_swap ? endian::byteswap16(raw2) : raw2);
 
                if (is_low_surrogate(c2)) {
                    cp = combine_surrogates(c1, c2).value();
                    consumed = 2;
                    return true;
                }
            }
 
            cp = 0xFFFD;
            return false;
        }
 
        if (is_low_surrogate(c1)) {
            cp = 0xFFFD;
            return false;
        }
 
        cp = c1;
        return true;
    }
 
public:
    constexpr codepoint() noexcept :
    value_(0) {}

    constexpr explicit codepoint(uint32_t value) noexcept :
    value_(is_valid_codepoint(value) ? value : REPLACEMENT_VALUE) {}

    constexpr explicit codepoint(const char32_t value) noexcept :
    codepoint(static_cast<uint32_t>(value)) {}
 
    constexpr codepoint(const codepoint&) noexcept = default;
    constexpr codepoint& operator=(const codepoint&) noexcept = default;
    constexpr codepoint(codepoint&&) noexcept = default;
    constexpr codepoint& operator=(codepoint&&) noexcept = default;

    constexpr uint32_t value() const noexcept { return value_; }

    constexpr char32_t to_char32() const noexcept { return static_cast<char32_t>(value_); }

    constexpr bool is_replacement() const noexcept { return value_ == REPLACEMENT_VALUE; }

    constexpr bool is_ascii() const noexcept { return value_ <= 0x7F; }

    constexpr bool is_bmp() const noexcept { return value_ <= 0xFFFF; }

    constexpr bool is_supplementary() const noexcept { return value_ > 0xFFFF && value_ <= MAX_VALUE; }

    constexpr bool needs_surrogate_pair() const noexcept { return is_supplementary(); }

    constexpr size_t utf8_length() const noexcept {
        if (value_ <= 0x7F) {
            return 1;
        }
        if (value_ <= 0x7FF) {
            return 2;
        }
        if (value_ <= 0xFFFF) {
            return 3;
        }
        return 4;
    }

    constexpr size_t utf16_length() const noexcept { return is_supplementary() ? 2u : 1u; }

    void append_to(string& result) const;
 
#ifdef NEFORCE_STANDARD_20
    void append_to(u8string& result) const;
#endif

    void append_to(u16string& result) const;

    void append_to(u32string& result) const { result.push_back(static_cast<char32_t>(value_)); }

    void append_to(wstring& result) const;
 
    constexpr bool operator==(const codepoint& other) const noexcept { return value_ == other.value_; }
    constexpr bool operator!=(const codepoint& other) const noexcept { return value_ != other.value_; }
    constexpr bool operator<(const codepoint& other) const noexcept { return value_ < other.value_; }
    constexpr bool operator<=(const codepoint& other) const noexcept { return value_ <= other.value_; }
    constexpr bool operator>(const codepoint& other) const noexcept { return value_ > other.value_; }
    constexpr bool operator>=(const codepoint& other) const noexcept { return value_ >= other.value_; }
 
    constexpr bool operator==(uint32_t v) const noexcept { return value_ == v; }
    constexpr bool operator!=(uint32_t v) const noexcept { return value_ != v; }
};
 // CodePoint
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_CODEPOINT_HPP__