hexadecimal.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_HEXADECIMAL_HPP__
#define NEFORCE_CORE_UTILITY_HEXADECIMAL_HPP__

 
#include "NeForce/core/interface/iobject.hpp"
#include "NeForce/core/string/format.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct NEFORCE_API hexadecimal : iobject<hexadecimal>, ipackage<hexadecimal, int64_t> {
public:
    using value_type = int64_t; 
    using base = ipackage;      
 
public:
    static constexpr byte_t invalid_xdigit = numeric_traits<byte_t>::max();

    static constexpr byte_t xdigit_value(const char c) noexcept {
        if (c >= '0' && c <= '9') {
            return c - '0';
        }
        if (c >= 'a' && c <= 'f') {
            return 10 + (c - 'a');
        }
        if (c >= 'A' && c <= 'F') {
            return 10 + (c - 'A');
        }
        return invalid_xdigit;
    }
 
    static NEFORCE_CONSTEXPR20 pair<bool, byte_t> xdigit_value(const char high, const char low) noexcept {
        const byte_t xhigh = xdigit_value(high);
        const byte_t xlow = xdigit_value(low);
        if (xhigh == invalid_xdigit || xlow == invalid_xdigit) {
            return {false, invalid_xdigit};
        }
        return pair<bool, byte_t>{true, high << 4 | low};
    }
 
private:
    static NEFORCE_CONSTEXPR20 value_type parse_view(const string_view view) {
        if (view.empty()) {
            return 0;
        }
 
        bool negative = false;
        size_t start = 0;
 
        while (start < view.size() && is_space(view[start])) {
            ++start;
        }
        if (start == view.size()) {
            return 0;
        }
 
        if (view[start] == '-') {
            negative = true;
            ++start;
        } else if (view[start] == '+') {
            ++start;
        }
 
        if (start + 1 < view.size() && view[start] == '0' && (view[start + 1] == 'x' || view[start + 1] == 'X')) {
            start += 2;
        }
 
        uint64_t result = 0;
        while (start < view.size()) {
            const char c = view[start++];
            if (is_xdigit(c)) {
                const int digit = xdigit_value(c);
                if (result > (numeric_traits<uint64_t>::max() >> 4)) {
                    NEFORCE_THROW_EXCEPTION(value_exception("Hexadecimal value too large"));
                }
                result = (result << 4) | static_cast<uint64_t>(digit);
            } else if (!is_space(c)) {
                NEFORCE_THROW_EXCEPTION(value_exception("Invalid hexadecimal character"));
            }
        }
 
        if (negative) {
            if (result > static_cast<uint64_t>(numeric_traits<int64_t>::max()) + 1) {
                NEFORCE_THROW_EXCEPTION(value_exception("Hexadecimal value out of range"));
            }
            return -static_cast<int64_t>(result);
        }
        if (result > static_cast<uint64_t>(numeric_traits<int64_t>::max())) {
            NEFORCE_THROW_EXCEPTION(value_exception("Hexadecimal value out of range"));
        }
        return static_cast<value_type>(result);
    }
 
public:
    explicit constexpr hexadecimal(const int16_t value) noexcept :
    base(value) {}

    explicit constexpr hexadecimal(const int32_t value) noexcept :
    base(value) {}

    explicit constexpr hexadecimal(const uint16_t value) noexcept :
    base(value) {}

    explicit constexpr hexadecimal(const uint32_t value) noexcept :
    base(value) {}

    explicit constexpr hexadecimal(const uint64_t value) noexcept :
    base(value) {}

    NEFORCE_CONSTEXPR20 explicit hexadecimal(const string_view view) :
    base(parse_view(view)) {}

    NEFORCE_CONSTEXPR20 explicit hexadecimal(const char* str) :
    hexadecimal(string_view(str)) {}

    NEFORCE_CONSTEXPR20 explicit hexadecimal(const string& str) :
    hexadecimal(str.view()) {}
 
    constexpr hexadecimal() noexcept = default;
    NEFORCE_CONSTEXPR20 ~hexadecimal() = default;
 
    constexpr hexadecimal(const hexadecimal&) noexcept = default;
    constexpr hexadecimal(hexadecimal&&) noexcept = default;
 
    constexpr hexadecimal& operator=(const hexadecimal& other) noexcept = default;
    constexpr hexadecimal& operator=(hexadecimal&& other) noexcept = default;
 
    explicit constexpr hexadecimal(const value_type value) noexcept :
    base(value) {}
 
    constexpr hexadecimal& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    NEFORCE_NODISCARD explicit constexpr operator bool() const noexcept { return value_ != static_cast<value_type>(0); }

    NEFORCE_NODISCARD constexpr bool get_bit(const size_t position) const {
        if (position >= 64) {
            NEFORCE_THROW_EXCEPTION(value_exception("Bit position out of range"));
        }
        return (value_ >> position) & 1;
    }

    constexpr hexadecimal& set_bit(const size_t position, const bool bit_value_ = true) {
        if (position >= 64) {
            NEFORCE_THROW_EXCEPTION(value_exception("Bit position out of range"));
        }
        if (bit_value_) {
            value_ |= (1ULL << position);
        } else {
            value_ &= ~(1ULL << position);
        }
        return *this;
    }

    constexpr hexadecimal& flip_bit(const size_t position) {
        if (position >= 64) {
            NEFORCE_THROW_EXCEPTION(value_exception("Bit position out of range"));
        }
        value_ ^= (1ULL << position);
        return *this;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const;

    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 hexadecimal parse(const string_view str) { return hexadecimal(str); }
};
 
template <>
struct unpackage<hexadecimal> {
    using type = int64_t;
};

 
NEFORCE_CONSTEXPR20 string hexadecimal::to_string() const { return format("{:#x}", *this); }

 // Packages
 
NEFORCE_BEGIN_LITERALS__


NEFORCE_CONSTEXPR20 hexadecimal operator""_hex(const char* str, const size_t len) {
    return hexadecimal{string_view(str, len)};
}

constexpr hexadecimal operator""_hex(const unsigned long long value) {
    return hexadecimal{static_cast<int64_t>(value)};
}
 // UserLiterals
 
NEFORCE_END_LITERALS__
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_HEXADECIMAL_HPP__