qchar.h - mozsearch

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2020 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:critical reason:data-parser

#ifndef QCHAR_H

#define QCHAR_H

#include <QtCore/qglobal.h>

#include <QtCore/qcompare.h>

#include <functional> // for std::hash

QT_BEGIN_NAMESPACE

class QString;

struct QLatin1Char

public:

    constexpr inline explicit QLatin1Char(char c) noexcept : ch(c) {}

    constexpr inline char toLatin1() const noexcept { return ch; }

    constexpr inline char16_t unicode() const noexcept { return char16_t(uchar(ch)); }

    friend constexpr bool

    comparesEqual(const QLatin1Char &lhs, const QLatin1Char &rhs) noexcept

    { return lhs.ch == rhs.ch; }

    friend constexpr Qt::strong_ordering

    compareThreeWay(const QLatin1Char &lhs, const QLatin1Char &rhs) noexcept

    { return Qt::compareThreeWay(uchar(lhs.ch), uchar(rhs.ch)); }

    Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(QLatin1Char)

    friend constexpr bool comparesEqual(const QLatin1Char &lhs, char rhs) noexcept

    { return lhs.toLatin1() == rhs; }

    friend constexpr Qt::strong_ordering

    compareThreeWay(const QLatin1Char &lhs, char rhs) noexcept

    { return Qt::compareThreeWay(uchar(lhs.toLatin1()), uchar(rhs)); }

    Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(QLatin1Char, char)

private:

    friend class QChar;

    // this is for QChar's ctor only:

    explicit constexpr operator char16_t() const noexcept { return unicode(); }

    char ch;

};

#define QT_CHAR_FASTCALL QT7_ONLY(Q_CORE_EXPORT) QT_FASTCALL

class QT6_ONLY(Q_CORE_EXPORT) QChar {

public:

    enum SpecialCharacter {

        Null = 0x0000,

        Tabulation = 0x0009,

        LineFeed = 0x000a,

        FormFeed = 0x000c,

        CarriageReturn = 0x000d,

        Space = 0x0020,

        Nbsp = 0x00a0,

        SoftHyphen = 0x00ad,

        ReplacementCharacter = 0xfffd,

        ObjectReplacementCharacter = 0xfffc,

        ByteOrderMark = 0xfeff,

        ByteOrderSwapped = 0xfffe,

        ParagraphSeparator = 0x2029,

        LineSeparator = 0x2028,

        VisualTabCharacter = 0x2192,

        LastValidCodePoint = 0x10ffff

};

#ifdef QT_IMPLICIT_QCHAR_CONSTRUCTION

#error This macro has been removed in Qt 6.8.

#endif

private:

    using is_wide_wchar_t = std::bool_constant<(sizeof(wchar_t) > 2)>;

    template <typename Char>

    using is_implicit_conversion_char = std::disjunction<

            std::is_same<Char, ushort>,

            std::is_same<Char, short>,

            std::is_same<Char, SpecialCharacter>,

            std::is_same<Char, QLatin1Char>,

            std::conjunction<std::is_same<Char, wchar_t>, std::negation<is_wide_wchar_t>>,

            std::is_same<Char, char16_t>

>;

    template <typename Char>

    using is_explicit_conversion_char = std::disjunction<

            std::is_same<Char, char32_t>, // implicit conversion to uint(?) before 6.8

            std::conjunction<std::is_same<Char, wchar_t>, is_wide_wchar_t>,

            std::is_same<Char, int>,

            std::is_same<Char, uint>

>;

    template <typename Char>

    using is_conversion_char = std::disjunction<

            is_implicit_conversion_char<Char>,

            is_explicit_conversion_char<Char>

>;

    template <typename Char>

    using is_implicit_ascii_warn_char = std::is_same<Char, char>;

    template <typename Char>

    using is_explicit_ascii_warn_char = std::is_same<Char, uchar>;

    template <typename Char>

    using if_compatible_char = std::enable_if_t<is_conversion_char<Char>::value, bool>;

    template <typename Char>

    using if_implicit_conversion_char = std::enable_if_t<is_implicit_conversion_char<Char>::value, bool>;

    template <typename Char>

    using if_explicit_conversion_char = std::enable_if_t<is_explicit_conversion_char<Char>::value, bool>;

    template <typename Char>

    using if_implicit_ascii_warn_char = std::enable_if_t<is_implicit_ascii_warn_char<Char>::value, bool>;

    template <typename Char>

    using if_explicit_ascii_warn_char = std::enable_if_t<is_explicit_ascii_warn_char<Char>::value, bool>;

    template <typename Char>

    [[maybe_unused]] static constexpr bool is_explicit_char_v = std::disjunction_v<

            is_explicit_conversion_char<Char>,

            is_explicit_ascii_warn_char<Char>

>;

public:

    constexpr Q_IMPLICIT QChar() noexcept : ucs(0) {}

#if QT_CORE_REMOVED_SINCE(6, 9) || defined(Q_QDOC)

    constexpr Q_IMPLICIT QChar(ushort rc) noexcept : ucs(rc) {}

#endif

    constexpr explicit QChar(uchar c, uchar r) noexcept : ucs(char16_t((r << 8) | c)) {}

#if QT_CORE_REMOVED_SINCE(6, 9) || defined(Q_QDOC)

    constexpr Q_IMPLICIT QChar(short rc) noexcept : ucs(char16_t(rc)) {}

    constexpr explicit QChar(uint rc) noexcept : ucs((Q_ASSERT(rc <= 0xffff), char16_t(rc))) {}

    constexpr explicit QChar(int rc) noexcept : QChar(uint(rc)) {}

    constexpr Q_IMPLICIT QChar(SpecialCharacter s) noexcept : ucs(char16_t(s)) {}

    constexpr Q_IMPLICIT QChar(QLatin1Char ch) noexcept : ucs(ch.unicode()) {}

    constexpr Q_IMPLICIT QChar(char16_t ch) noexcept : ucs(ch) {}

#if defined(Q_OS_WIN) || defined(Q_QDOC)

    constexpr Q_IMPLICIT QChar(wchar_t ch) noexcept : ucs(char16_t(ch)) {}

#endif

#endif // QT_CORE_REMOVED_SINCE(6, 9)

    template <typename Char, if_implicit_conversion_char<Char> = true>

    constexpr Q_IMPLICIT QChar(const Char ch) noexcept : ucs(char16_t(ch)) {}

    template <typename Char, if_explicit_conversion_char<Char> = true>

    constexpr explicit QChar(const Char ch) noexcept

        : ucs((Q_ASSERT(char32_t(ch) <= 0xffff), char16_t(ch))) {}

#ifndef QT_NO_CAST_FROM_ASCII

    // Always implicit -- allow for 'x' => QChar conversions

#if QT_CORE_REMOVED_SINCE(6, 9) || defined(Q_QDOC)

    QT_ASCII_CAST_WARN constexpr Q_IMPLICIT QChar(char c) noexcept : ucs(uchar(c)) { }

#endif

    template <typename Char, if_implicit_ascii_warn_char<Char> = true>

    QT_ASCII_CAST_WARN constexpr Q_IMPLICIT QChar(const Char ch) noexcept : ucs(uchar(ch)) {}

#ifndef QT_RESTRICTED_CAST_FROM_ASCII

#if QT_CORE_REMOVED_SINCE(6, 9) || defined(Q_QDOC)

    QT_ASCII_CAST_WARN constexpr explicit QChar(uchar c) noexcept : ucs(c) { }

#endif

    template <typename Char, if_explicit_ascii_warn_char<Char> = true>

    QT_ASCII_CAST_WARN constexpr explicit QChar(const Char c) noexcept : ucs(c) { }

#endif

#endif

    static constexpr QChar fromUcs2(char16_t c) noexcept { return QChar{c}; }

    [[nodiscard]] static constexpr inline auto fromUcs4(char32_t c) noexcept

        struct R {

            char16_t chars[2];

            [[nodiscard]] constexpr qsizetype size() const noexcept { return chars[1] ? 2 : 1; }

            [[nodiscard]] constexpr const char16_t *data() const noexcept { return chars; }

            [[nodiscard]] constexpr const char16_t *begin() const noexcept { return chars; }

            [[nodiscard]] constexpr const char16_t *end() const noexcept { return begin() + size(); }

};

        return requiresSurrogates(c) ? R{{QChar::highSurrogate(c),

                                          QChar::lowSurrogate(c)}} :

                                       R{{char16_t(c), u'\0'}} ;

    // Unicode information

    enum Category

        Mark_NonSpacing,          //   Mn

        Mark_SpacingCombining,    //   Mc

        Mark_Enclosing,           //   Me

        Number_DecimalDigit,      //   Nd

        Number_Letter,            //   Nl

        Number_Other,             //   No

        Separator_Space,          //   Zs

        Separator_Line,           //   Zl

        Separator_Paragraph,      //   Zp

        Other_Control,            //   Cc

        Other_Format,             //   Cf

        Other_Surrogate,          //   Cs

        Other_PrivateUse,         //   Co

        Other_NotAssigned,        //   Cn

        Letter_Uppercase,         //   Lu

        Letter_Lowercase,         //   Ll

        Letter_Titlecase,         //   Lt

        Letter_Modifier,          //   Lm

        Letter_Other,             //   Lo

        Punctuation_Connector,    //   Pc

        Punctuation_Dash,         //   Pd

        Punctuation_Open,         //   Ps

        Punctuation_Close,        //   Pe

        Punctuation_InitialQuote, //   Pi

        Punctuation_FinalQuote,   //   Pf

        Punctuation_Other,        //   Po

        Symbol_Math,              //   Sm

        Symbol_Currency,          //   Sc

        Symbol_Modifier,          //   Sk

        Symbol_Other              //   So

};

    enum Script

        Script_Unknown,

        Script_Inherited,

        Script_Common,

        Script_Latin,

        Script_Greek,

        Script_Cyrillic,

        Script_Armenian,

        Script_Hebrew,

        Script_Arabic,

        Script_Syriac,

        Script_Thaana,

        Script_Devanagari,

        Script_Bengali,

        Script_Gurmukhi,

        Script_Gujarati,

        Script_Oriya,

        Script_Tamil,

        Script_Telugu,

        Script_Kannada,

        Script_Malayalam,

        Script_Sinhala,

        Script_Thai,

        Script_Lao,

        Script_Tibetan,

        Script_Myanmar,

        Script_Georgian,

        Script_Hangul,

        Script_Ethiopic,

        Script_Cherokee,

        Script_CanadianAboriginal,

        Script_Ogham,

        Script_Runic,

        Script_Khmer,

        Script_Mongolian,

        Script_Hiragana,

        Script_Katakana,

        Script_Bopomofo,

        Script_Han,

        Script_Yi,

        Script_OldItalic,

        Script_Gothic,

        Script_Deseret,

        Script_Tagalog,

        Script_Hanunoo,

        Script_Buhid,

        Script_Tagbanwa,

        Script_Coptic,

        // Unicode 4.0 additions

        Script_Limbu,

        Script_TaiLe,

        Script_LinearB,

        Script_Ugaritic,

        Script_Shavian,

        Script_Osmanya,

        Script_Cypriot,

        Script_Braille,

        // Unicode 4.1 additions

        Script_Buginese,

        Script_NewTaiLue,

        Script_Glagolitic,

        Script_Tifinagh,

        Script_SylotiNagri,

        Script_OldPersian,

        Script_Kharoshthi,

        // Unicode 5.0 additions

        Script_Balinese,

        Script_Cuneiform,

        Script_Phoenician,

        Script_PhagsPa,

        Script_Nko,

        // Unicode 5.1 additions

        Script_Sundanese,

        Script_Lepcha,

        Script_OlChiki,

        Script_Vai,

        Script_Saurashtra,

        Script_KayahLi,

        Script_Rejang,

        Script_Lycian,

        Script_Carian,

        Script_Lydian,

        Script_Cham,

        // Unicode 5.2 additions

        Script_TaiTham,

        Script_TaiViet,

        Script_Avestan,

        Script_EgyptianHieroglyphs,

        Script_Samaritan,

        Script_Lisu,

        Script_Bamum,

        Script_Javanese,

        Script_MeeteiMayek,

        Script_ImperialAramaic,

        Script_OldSouthArabian,

        Script_InscriptionalParthian,

        Script_InscriptionalPahlavi,

        Script_OldTurkic,

        Script_Kaithi,

        // Unicode 6.0 additions

        Script_Batak,

        Script_Brahmi,

        Script_Mandaic,

        // Unicode 6.1 additions

        Script_Chakma,

        Script_MeroiticCursive,

        Script_MeroiticHieroglyphs,

        Script_Miao,

        Script_Sharada,

        Script_SoraSompeng,

        Script_Takri,

        // Unicode 7.0 additions

        Script_CaucasianAlbanian,

        Script_BassaVah,

        Script_Duployan,

        Script_Elbasan,

        Script_Grantha,

        Script_PahawhHmong,

        Script_Khojki,

        Script_LinearA,

        Script_Mahajani,

        Script_Manichaean,

        Script_MendeKikakui,

        Script_Modi,

        Script_Mro,

        Script_OldNorthArabian,

        Script_Nabataean,

        Script_Palmyrene,

        Script_PauCinHau,

        Script_OldPermic,

        Script_PsalterPahlavi,

        Script_Siddham,

        Script_Khudawadi,

        Script_Tirhuta,

        Script_WarangCiti,

        // Unicode 8.0 additions

        Script_Ahom,

        Script_AnatolianHieroglyphs,

        Script_Hatran,

        Script_Multani,

        Script_OldHungarian,

        Script_SignWriting,

        // Unicode 9.0 additions

        Script_Adlam,

        Script_Bhaiksuki,

        Script_Marchen,

        Script_Newa,

        Script_Osage,

        Script_Tangut,

        // Unicode 10.0 additions

        Script_MasaramGondi,

        Script_Nushu,

        Script_Soyombo,

        Script_ZanabazarSquare,

        // Unicode 12.1 additions

        Script_Dogra,

        Script_GunjalaGondi,

        Script_HanifiRohingya,

        Script_Makasar,

        Script_Medefaidrin,

        Script_OldSogdian,

        Script_Sogdian,

        Script_Elymaic,

        Script_Nandinagari,

        Script_NyiakengPuachueHmong,

        Script_Wancho,

        // Unicode 13.0 additions

        Script_Chorasmian,

        Script_DivesAkuru,

        Script_KhitanSmallScript,

        Script_Yezidi,

        // Unicode 14.0 additions

        Script_CyproMinoan,

        Script_OldUyghur,

        Script_Tangsa,

        Script_Toto,

        Script_Vithkuqi,

        // Unicode 15.0 additions

        Script_Kawi,

        Script_NagMundari,

        // Unicode 16.0 additions

        Script_Garay,

        Script_GurungKhema,

        Script_KiratRai,

        Script_OlOnal,

        Script_Sunuwar,

        Script_Todhri,

        Script_TuluTigalari,

        // Unicode 17.0 additions

        Script_Sidetic,

        Script_TaiYo,

        Script_TolongSiki,

        Script_BeriaErfe,

        ScriptCount

};

    enum Direction

        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,

        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN,

        DirLRI, DirRLI, DirFSI, DirPDI

};

    enum Decomposition

        NoDecomposition,

        Canonical,

        Font,

        NoBreak,

        Initial,

        Medial,

        Final,

        Isolated,

        Circle,

        Super,

        Sub,

        Vertical,

        Wide,

        Narrow,

        Small,

        Square,

        Compat,

        Fraction

};

    enum JoiningType {

        Joining_None,

        Joining_Causing,

        Joining_Dual,

        Joining_Right,

        Joining_Left,

        Joining_Transparent

};

    enum CombiningClass

        Combining_BelowLeftAttached       = 200,

        Combining_BelowAttached           = 202,

        Combining_BelowRightAttached      = 204,

        Combining_LeftAttached            = 208,

        Combining_RightAttached           = 210,

        Combining_AboveLeftAttached       = 212,

        Combining_AboveAttached           = 214,

        Combining_AboveRightAttached      = 216,

        Combining_BelowLeft               = 218,

        Combining_Below                   = 220,

        Combining_BelowRight              = 222,

        Combining_Left                    = 224,

        Combining_Right                   = 226,

        Combining_AboveLeft               = 228,

        Combining_Above                   = 230,

        Combining_AboveRight              = 232,

        Combining_DoubleBelow             = 233,

        Combining_DoubleAbove             = 234,

        Combining_IotaSubscript           = 240

};

    enum UnicodeVersion {

        Unicode_Unassigned,

        Unicode_1_1,

        Unicode_2_0,

        Unicode_2_1_2,

        Unicode_3_0,

        Unicode_3_1,

        Unicode_3_2,

        Unicode_4_0,

        Unicode_4_1,

        Unicode_5_0,

        Unicode_5_1,

        Unicode_5_2,

        Unicode_6_0,

        Unicode_6_1,

        Unicode_6_2,

        Unicode_6_3,

        Unicode_7_0,

        Unicode_8_0,

        Unicode_9_0,

        Unicode_10_0,

        Unicode_11_0,

        Unicode_12_0,

        Unicode_12_1,

        Unicode_13_0,

        Unicode_14_0,

        Unicode_15_0,

        Unicode_15_1,

        Unicode_16_0,

        Unicode_17_0,

};

    Category category() const noexcept { return QChar::category(char32_t(ucs)); }

    Direction direction() const noexcept { return QChar::direction(char32_t(ucs)); }

    JoiningType joiningType() const noexcept { return QChar::joiningType(char32_t(ucs)); }

    unsigned char combiningClass() const noexcept { return QChar::combiningClass(char32_t(ucs)); }

    QChar mirroredChar() const noexcept { return QChar(QChar::mirroredChar(char32_t(ucs))); }

    bool hasMirrored() const noexcept { return QChar::hasMirrored(char32_t(ucs)); }

    QString decomposition() const;

    Decomposition decompositionTag() const noexcept { return QChar::decompositionTag(char32_t(ucs)); }

    int digitValue() const noexcept { return QChar::digitValue(char32_t(ucs)); }

    QChar toLower() const noexcept { return QChar(QChar::toLower(char32_t(ucs))); }

    QChar toUpper() const noexcept { return QChar(QChar::toUpper(char32_t(ucs))); }

    QChar toTitleCase() const noexcept { return QChar(QChar::toTitleCase(char32_t(ucs))); }

    QChar toCaseFolded() const noexcept { return QChar(QChar::toCaseFolded(char32_t(ucs))); }

    Script script() const noexcept { return QChar::script(char32_t(ucs)); }

    UnicodeVersion unicodeVersion() const noexcept { return QChar::unicodeVersion(char32_t(ucs)); }

    constexpr inline char toLatin1() const noexcept { return ucs > 0xff ? '\0' : char(ucs); }

    constexpr inline char16_t unicode() const noexcept { return ucs; }

    constexpr inline char16_t &unicode() noexcept { return ucs; }

    static constexpr QChar fromLatin1(char c) noexcept { return QLatin1Char(c); }

    constexpr inline bool isNull() const noexcept { return ucs == 0; }

    bool isPrint() const noexcept { return QChar::isPrint(char32_t(ucs)); }

    constexpr bool isSpace() const noexcept { return QChar::isSpace(char32_t(ucs)); }

    bool isMark() const noexcept { return QChar::isMark(char32_t(ucs)); }

    bool isPunct() const noexcept { return QChar::isPunct(char32_t(ucs)); }

    bool isSymbol() const noexcept { return QChar::isSymbol(char32_t(ucs)); }

    constexpr bool isLetter() const noexcept { return QChar::isLetter(char32_t(ucs)); }

    constexpr bool isNumber() const noexcept { return QChar::isNumber(char32_t(ucs)); }

    constexpr bool isLetterOrNumber() const noexcept { return QChar::isLetterOrNumber(char32_t(ucs)); }

    constexpr bool isDigit() const noexcept { return QChar::isDigit(char32_t(ucs)); }

    constexpr bool isLower() const noexcept { return QChar::isLower(char32_t(ucs)); }

    constexpr bool isUpper() const noexcept { return QChar::isUpper(char32_t(ucs)); }

    constexpr bool isTitleCase() const noexcept { return QChar::isTitleCase(char32_t(ucs)); }

    constexpr bool isNonCharacter() const noexcept { return QChar::isNonCharacter(char32_t(ucs)); }

    constexpr bool isHighSurrogate() const noexcept { return QChar::isHighSurrogate(char32_t(ucs)); }

    constexpr bool isLowSurrogate() const noexcept { return QChar::isLowSurrogate(char32_t(ucs)); }

    constexpr bool isSurrogate() const noexcept { return QChar::isSurrogate(char32_t(ucs)); }

    constexpr inline uchar cell() const noexcept { return uchar(ucs & 0xff); }

    constexpr inline uchar row() const noexcept { return uchar((ucs>>8)&0xff); }

    constexpr inline void setCell(uchar acell) noexcept { ucs = char16_t((ucs & 0xff00) + acell); }

    constexpr inline void setRow(uchar arow) noexcept { ucs = char16_t((char16_t(arow)<<8) + (ucs&0xff)); }

    static constexpr inline bool isNonCharacter(char32_t ucs4) noexcept

        return ucs4 >= 0xfdd0 && (ucs4 <= 0xfdef || (ucs4 & 0xfffe) == 0xfffe);

    static constexpr inline bool isHighSurrogate(char32_t ucs4) noexcept

        return (ucs4 & 0xfffffc00) == 0xd800; // 0xd800 + up to 1023 (0x3ff)

    static constexpr inline bool isLowSurrogate(char32_t ucs4) noexcept

        return (ucs4 & 0xfffffc00) == 0xdc00; // 0xdc00 + up to 1023 (0x3ff)

    static constexpr inline bool isSurrogate(char32_t ucs4) noexcept

        return (ucs4 - 0xd800u < 2048u);

    static constexpr inline bool requiresSurrogates(char32_t ucs4) noexcept

        return (ucs4 >= 0x10000);

    static constexpr inline char32_t surrogateToUcs4(char16_t high, char16_t low) noexcept

        // 0x010000 through 0x10ffff, provided params are actual high, low surrogates.

        // 0x010000 + ((high - 0xd800) << 10) + (low - 0xdc00), optimized:

        return (char32_t(high)<<10) + low - 0x35fdc00;

    static constexpr inline char32_t surrogateToUcs4(QChar high, QChar low) noexcept

        return surrogateToUcs4(high.ucs, low.ucs);

    static constexpr inline char16_t highSurrogate(char32_t ucs4) noexcept

        return char16_t((ucs4>>10) + 0xd7c0);

    static constexpr inline char16_t lowSurrogate(char32_t ucs4) noexcept

        return char16_t(ucs4%0x400 + 0xdc00);

    Q_DECL_CONST_FUNCTION static Category QT_CHAR_FASTCALL category(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static Direction QT_CHAR_FASTCALL direction(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static JoiningType QT_CHAR_FASTCALL joiningType(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static unsigned char QT_CHAR_FASTCALL combiningClass(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static char32_t QT_CHAR_FASTCALL mirroredChar(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL hasMirrored(char32_t ucs4) noexcept;

    static QString QT_CHAR_FASTCALL decomposition(char32_t ucs4);

    Q_DECL_CONST_FUNCTION static Decomposition QT_CHAR_FASTCALL decompositionTag(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static int QT_CHAR_FASTCALL digitValue(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static char32_t QT_CHAR_FASTCALL toLower(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static char32_t QT_CHAR_FASTCALL toUpper(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static char32_t QT_CHAR_FASTCALL toTitleCase(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static char32_t QT_CHAR_FASTCALL toCaseFolded(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static Script QT_CHAR_FASTCALL script(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static UnicodeVersion QT_CHAR_FASTCALL unicodeVersion(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static UnicodeVersion QT_CHAR_FASTCALL currentUnicodeVersion() noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isPrint(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static constexpr inline bool isSpace(char32_t ucs4) noexcept

        // note that [0x09..0x0d] + 0x85 are exceptional Cc-s and must be handled explicitly

        return ucs4 == 0x20 || (ucs4 <= 0x0d && ucs4 >= 0x09)

                || (ucs4 > 127 && (ucs4 == 0x85 || ucs4 == 0xa0 || QChar::isSpace_helper(ucs4)));

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isMark(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isPunct(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isSymbol(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static constexpr inline bool isLetter(char32_t ucs4) noexcept

        return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))

                || (ucs4 > 127 && QChar::isLetter_helper(ucs4));

    Q_DECL_CONST_FUNCTION static constexpr inline bool isNumber(char32_t ucs4) noexcept

    { return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::isNumber_helper(ucs4)); }

    Q_DECL_CONST_FUNCTION static constexpr inline bool isLetterOrNumber(char32_t ucs4) noexcept

        return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))

                || (ucs4 >= '0' && ucs4 <= '9')

                || (ucs4 > 127 && QChar::isLetterOrNumber_helper(ucs4));

    Q_DECL_CONST_FUNCTION static constexpr inline bool isDigit(char32_t ucs4) noexcept

    { return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::category(ucs4) == Number_DecimalDigit); }

    Q_DECL_CONST_FUNCTION static constexpr inline bool isLower(char32_t ucs4) noexcept

    { return (ucs4 <= 'z' && ucs4 >= 'a') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Lowercase); }

    Q_DECL_CONST_FUNCTION static constexpr inline bool isUpper(char32_t ucs4) noexcept

    { return (ucs4 <= 'Z' && ucs4 >= 'A') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Uppercase); }

    Q_DECL_CONST_FUNCTION static constexpr inline bool isTitleCase(char32_t ucs4) noexcept

    { return ucs4 > 127 && QChar::category(ucs4) == Letter_Titlecase; }

    friend constexpr bool comparesEqual(const QChar &lhs, const QChar &rhs) noexcept

    { return lhs.ucs == rhs.ucs; }

    friend constexpr Qt::strong_ordering

    compareThreeWay(const QChar &lhs, const QChar &rhs) noexcept

    { return Qt::compareThreeWay(lhs.ucs, rhs.ucs); }

    Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(QChar)

    friend constexpr bool comparesEqual(const QChar &lhs, std::nullptr_t) noexcept

    { return lhs.isNull(); }

    friend constexpr Qt::strong_ordering

    compareThreeWay(const QChar &lhs, std::nullptr_t) noexcept

    { return lhs.isNull() ? Qt::strong_ordering::equivalent : Qt::strong_ordering::greater; }

    Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(QChar, std::nullptr_t)

private:

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isSpace_helper(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isLetter_helper(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isNumber_helper(char32_t ucs4) noexcept;

    Q_DECL_CONST_FUNCTION static bool QT_CHAR_FASTCALL isLetterOrNumber_helper(char32_t ucs4) noexcept;

    // defined in qstring.cpp, because we need to go via QUtf8StringView

    static bool QT_CHAR_FASTCALL

    Q_DECL_CONST_FUNCTION equal_helper(QChar lhs, const char *rhs) noexcept;

    static int QT_CHAR_FASTCALL

    Q_DECL_CONST_FUNCTION compare_helper(QChar lhs, const char *rhs) noexcept;

#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)

    Q_WEAK_OVERLOAD

    friend bool comparesEqual(const QChar &lhs, const char *rhs) noexcept

    { return equal_helper(lhs, rhs); }

    Q_WEAK_OVERLOAD

    friend Qt::strong_ordering compareThreeWay(const QChar &lhs, const char *rhs) noexcept

        const int res = compare_helper(lhs, rhs);

        return Qt::compareThreeWay(res, 0);

    Q_DECLARE_STRONGLY_ORDERED(QChar, const char *, Q_WEAK_OVERLOAD QT_ASCII_CAST_WARN)

#endif // !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)

    char16_t ucs;

};

#undef QT_CHAR_FASTCALL

Q_DECLARE_TYPEINFO(QChar, Q_PRIMITIVE_TYPE);

namespace Qt {

inline namespace Literals {

inline namespace StringLiterals {

constexpr inline QLatin1Char operator""_L1(char ch) noexcept

    return QLatin1Char(ch);

} // StringLiterals

} // Literals

} // Qt

QT_END_NAMESPACE

namespace std {

template <>

struct hash<QT_PREPEND_NAMESPACE(QChar)>

    template <typename = void> // for transparent constexpr tracking

    constexpr size_t operator()(QT_PREPEND_NAMESPACE(QChar) c) const

        noexcept(noexcept(std::hash<char16_t>{}(u' ')))

        return std::hash<char16_t>{}(c.unicode());

};

} // namespace std

#endif // QCHAR_H