char_types.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_CHAR_TYPES_HPP__
#define NEFORCE_CORE_STRING_CHAR_TYPES_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_BEGIN_CONSTANTS__

NEFORCE_INLINE17 constexpr uint64_t BLANK_MASK = (1ULL << 9) | // \t
                                                 (1ULL << 32); // space

NEFORCE_INLINE17 constexpr uint64_t SPACE_MASK = BLANK_MASK | (1ULL << 10) | // \n
                                                 (1ULL << 11) |              // \v
                                                 (1ULL << 12) |              // \f
                                                 (1ULL << 13);               // \r

NEFORCE_INLINE17 constexpr uint64_t PUNCT_MASK_LOW =
        (1ULL << 33) | (1ULL << 34) | (1ULL << 35) | (1ULL << 36) | // !"#$ (33~36 < 64)
        (1ULL << 37) | (1ULL << 38) | (1ULL << 39) | (1ULL << 40) | // %&'() (37~40 < 64)
        (1ULL << 41) | (1ULL << 42) | (1ULL << 43) | (1ULL << 44) | // *+,- (41~44 < 64)
        (1ULL << 45) | (1ULL << 46) | (1ULL << 47) | (1ULL << 58) | // ./: (45~47,58 < 64)
        (1ULL << 59) | (1ULL << 60) | (1ULL << 61) | (1ULL << 62) | // ;<=> (59~62 < 64)
        (1ULL << 63);                                               // ?

NEFORCE_INLINE17 constexpr uint64_t PUNCT_MASK_HIGH =
        (1ULL << (64 - 64)) | (1ULL << (65 - 64)) | (1ULL << (91 - 64)) | // @(64)、A(65)、[(91)
        (1ULL << (92 - 64)) | (1ULL << (93 - 64)) | (1ULL << (94 - 64)) |
        (1ULL << (95 - 64)) | // \\‍(92)、](93)、^(94)、_(95)
        (1ULL << (96 - 64)) | (1ULL << (123 - 64)) | (1ULL << (124 - 64)) |
        (1ULL << (125 - 64)) | // `(96)、{(123)、|(124)、}(125)
        (1ULL << (126 - 64));  // ~(126)

NEFORCE_INLINE17 constexpr uint64_t CNTRL_MASK_LOW =
        (1ULL << 0) | (1ULL << 1) | (1ULL << 2) | (1ULL << 3) |     // 0-3 (0~3 < 64)
        (1ULL << 4) | (1ULL << 5) | (1ULL << 6) | (1ULL << 7) |     // 4-7 (4~7 < 64)
        (1ULL << 8) | (1ULL << 9) | (1ULL << 10) | (1ULL << 11) |   // 8-11 (8~11 < 64)
        (1ULL << 12) | (1ULL << 13) | (1ULL << 14) | (1ULL << 15) | // 12-15 (12~15 < 64)
        (1ULL << 16) | (1ULL << 17) | (1ULL << 18) | (1ULL << 19) | // 16-19 (16~19 < 64)
        (1ULL << 20) | (1ULL << 21) | (1ULL << 22) | (1ULL << 23) | // 20-23 (20~23 < 64)
        (1ULL << 24) | (1ULL << 25) | (1ULL << 26) | (1ULL << 27) | // 24-27 (24~27 < 64)
        (1ULL << 28) | (1ULL << 29) | (1ULL << 30) | (1ULL << 31);  // 30-31 (30~31 < 64)

NEFORCE_INLINE17 constexpr uint64_t CNTRL_MASK_HIGH = (1ULL << (127 - 64)); // DEL(127)
 
NEFORCE_END_CONSTANTS__
 

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_ctype(const CharT c, uint64_t mask_low, uint64_t mask_high) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    if (uc > 127) {
        return false;
    }
    if (uc <= 63) {
        return (mask_low & (1ULL << uc)) != 0;
    }
    const auto offset = uc - 64;
    return (mask_high & (1ULL << offset)) != 0;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_punct(const CharT c) noexcept {
    return _NEFORCE is_ctype(c, constants::PUNCT_MASK_LOW, constants::PUNCT_MASK_HIGH);
}

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_cntrl(const CharT c) noexcept {
    return _NEFORCE is_ctype(c, constants::CNTRL_MASK_LOW, constants::CNTRL_MASK_HIGH);
}

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_print(const CharT c) noexcept {
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    return uc <= 127 && !_NEFORCE is_cntrl(c);
}

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_blank(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    return uc < 64 && (constants::BLANK_MASK & (1ULL << uc)) != 0;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_graph(const CharT c) noexcept {
    return _NEFORCE is_print(c) && !_NEFORCE is_blank(c);
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 bool is_ascii(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    return uc <= 127;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 bool is_space(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    return uc < 64 && (constants::SPACE_MASK & (1ULL << uc)) != 0;
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 bool is_alpha(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    if (uc > 127) {
        return false;
    }
    return (uc & 0xDF) >= 'A' && (uc & 0xDF) <= 'Z';
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 bool is_digit(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    if (uc > 127) {
        return false;
    }
    return (uc & 0xF0) == 0x30 && (uc & 0x0F) <= 9;
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 bool is_xdigit(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character required");
    const auto uc = static_cast<make_unsigned_t<CharT>>(c);
    if (uc > 127) {
        return false;
    }
    const bool is_09 = (uc & 0xF0) == 0x30 && (uc & 0x0F) <= 0x09;
    const bool is_AF = (uc & 0xF0) == 0x40 && (uc & 0x0F) >= 0x01 && (uc & 0x0F) <= 0x06;
    const bool is_af = (uc & 0xF0) == 0x60 && (uc & 0x0F) >= 0x01 && (uc & 0x0F) <= 0x06;
    return is_09 || is_AF || is_af;
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 bool is_alpha_or_digit(const CharT c) noexcept {
    return _NEFORCE is_alpha(c) || _NEFORCE is_digit(c);
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 bool is_digit_or_alpha(const CharT c) noexcept {
    return _NEFORCE is_digit(c) || _NEFORCE is_alpha(c);
}
 // CharTypeChecking
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_CHAR_TYPES_HPP__