charset.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_CHARSET_HPP__
#define NEFORCE_CORE_STRING_CHARSET_HPP__

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


class charset {
public:
    constexpr charset() noexcept = default;

    NEFORCE_NODISCARD static constexpr charset from_char(const char c) noexcept {
        charset cs;
        cs.insert(c);
        return cs;
    }

    NEFORCE_NODISCARD static constexpr charset range(const char lo, const char hi) noexcept {
        charset cs;
        const auto u_lo = static_cast<byte_t>(lo);
        const auto u_hi = static_cast<byte_t>(hi);
        if (u_lo > u_hi) {
            return cs;
        }
 
        for (int w = 0; w < 4; ++w) {
            const unsigned word_start = static_cast<unsigned>(w) * 64;
            const unsigned word_end = word_start + 63;
            if (u_hi < word_start || u_lo > word_end) {
                continue;
            }
            const unsigned local_lo = (u_lo > word_start) ? (u_lo - word_start) : 0;
            const unsigned local_hi = (u_hi < word_end) ? (u_hi - word_start) : 63;
            const uint64_t mask = (~uint64_t{0} >> (63 - local_hi)) & (~uint64_t{0} << local_lo);
            cs.bits_[w] = mask;
        }
        return cs;
    }

    constexpr void insert(const char c) noexcept {
        const auto idx = static_cast<byte_t>(c);
        bits_[idx >> 6] |= (uint64_t{1} << (idx & 63));
    }

    constexpr void erase(const char c) noexcept {
        const auto idx = static_cast<byte_t>(c);
        bits_[idx >> 6] &= ~(uint64_t{1} << (idx & 63));
    }

    NEFORCE_NODISCARD constexpr bool contains(const char c) const noexcept {
        const auto idx = static_cast<byte_t>(c);
        return (bits_[idx >> 6] & (uint64_t{1} << (idx & 63))) != 0;
    }

    NEFORCE_NODISCARD constexpr bool empty() const noexcept { return (bits_[0] | bits_[1] | bits_[2] | bits_[3]) == 0; }

    NEFORCE_NODISCARD constexpr charset operator|(const charset other) const noexcept {
        charset result;
        result.bits_[0] = bits_[0] | other.bits_[0];
        result.bits_[1] = bits_[1] | other.bits_[1];
        result.bits_[2] = bits_[2] | other.bits_[2];
        result.bits_[3] = bits_[3] | other.bits_[3];
        return result;
    }

    NEFORCE_NODISCARD constexpr charset operator&(const charset other) const noexcept {
        charset result;
        result.bits_[0] = bits_[0] & other.bits_[0];
        result.bits_[1] = bits_[1] & other.bits_[1];
        result.bits_[2] = bits_[2] & other.bits_[2];
        result.bits_[3] = bits_[3] & other.bits_[3];
        return result;
    }

    NEFORCE_NODISCARD constexpr charset operator~() const noexcept {
        charset result;
        result.bits_[0] = ~bits_[0];
        result.bits_[1] = ~bits_[1];
        result.bits_[2] = ~bits_[2];
        result.bits_[3] = ~bits_[3];
        return result;
    }

    NEFORCE_NODISCARD constexpr charset operator-(const charset other) const noexcept { return *this & ~other; }

    constexpr charset& operator|=(const charset other) noexcept {
        bits_[0] |= other.bits_[0];
        bits_[1] |= other.bits_[1];
        bits_[2] |= other.bits_[2];
        bits_[3] |= other.bits_[3];
        return *this;
    }

    constexpr charset& operator&=(const charset other) noexcept {
        bits_[0] &= other.bits_[0];
        bits_[1] &= other.bits_[1];
        bits_[2] &= other.bits_[2];
        bits_[3] &= other.bits_[3];
        return *this;
    }

    constexpr charset& operator-=(const charset other) noexcept {
        bits_[0] &= ~other.bits_[0];
        bits_[1] &= ~other.bits_[1];
        bits_[2] &= ~other.bits_[2];
        bits_[3] &= ~other.bits_[3];
        return *this;
    }

    NEFORCE_NODISCARD constexpr bool operator==(const charset other) const noexcept {
        return bits_[0] == other.bits_[0] && bits_[1] == other.bits_[1] && bits_[2] == other.bits_[2] &&
               bits_[3] == other.bits_[3];
    }

    NEFORCE_NODISCARD constexpr bool operator!=(const charset other) const noexcept { return !(*this == other); }

    NEFORCE_NODISCARD static constexpr charset empty_set() noexcept { return charset{}; }

    NEFORCE_NODISCARD static constexpr charset universe() noexcept {
        charset cs;
        cs.bits_[0] = ~uint64_t{0};
        cs.bits_[1] = ~uint64_t{0};
        cs.bits_[2] = ~uint64_t{0};
        cs.bits_[3] = ~uint64_t{0};
        return cs;
    }

    NEFORCE_NODISCARD static constexpr charset ascii_alpha_lower() noexcept { return range('a', 'z'); }

    NEFORCE_NODISCARD static constexpr charset ascii_alpha_upper() noexcept { return range('A', 'Z'); }

    NEFORCE_NODISCARD static constexpr charset ascii_alpha() noexcept {
        return ascii_alpha_lower() | ascii_alpha_upper();
    }

    NEFORCE_NODISCARD static constexpr charset ascii_digit() noexcept { return range('0', '9'); }

    NEFORCE_NODISCARD static constexpr charset ascii_alnum() noexcept { return ascii_alpha() | ascii_digit(); }

    NEFORCE_NODISCARD static constexpr charset ascii_hex_digit() noexcept {
        return ascii_digit() | range('A', 'F') | range('a', 'f');
    }

    NEFORCE_NODISCARD static constexpr charset ascii_blank() noexcept {
        charset cs;
        cs.bits_[0] = constants::BLANK_MASK;
        return cs;
    }

    NEFORCE_NODISCARD static constexpr charset ascii_space() noexcept {
        charset cs;
        cs.bits_[0] = constants::SPACE_MASK;
        return cs;
    }

    NEFORCE_NODISCARD static constexpr charset ascii_punct() noexcept {
        charset cs;
        cs.bits_[0] = constants::PUNCT_MASK_LOW;
        cs.bits_[1] = constants::PUNCT_MASK_HIGH;
        return cs;
    }

    NEFORCE_NODISCARD static constexpr charset ascii_cntrl() noexcept {
        charset cs;
        cs.bits_[0] = constants::CNTRL_MASK_LOW;
        cs.bits_[1] = constants::CNTRL_MASK_HIGH;
        return cs;
    }

    NEFORCE_NODISCARD static constexpr charset ascii_print() noexcept { return range(' ', '~'); }

    NEFORCE_NODISCARD static constexpr charset ascii_graph() noexcept { return ascii_print() - ascii_blank(); }
 
private:
    uint64_t bits_[4] = {}; 
};
 // Charset
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_CHARSET_HPP__