packages.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_PACKAGES_HPP__
#define NEFORCE_CORE_UTILITY_PACKAGES_HPP__

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


struct boolean : ipackage<boolean, bool>, iobject<boolean> {
    using value_type = bool;
    using base = ipackage;
 
    constexpr boolean() noexcept = default;
    NEFORCE_CONSTEXPR20 ~boolean() = default;
 
    constexpr boolean(const boolean&) noexcept = default;
    constexpr boolean(boolean&&) noexcept = default;
 
    constexpr boolean& operator=(const boolean& other) noexcept = default;
    constexpr boolean& operator=(boolean&& other) noexcept = default;
 
    explicit constexpr boolean(const value_type value) noexcept :
    base(value) {}
 
    constexpr boolean& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {
        return boolean(value).to_string();
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return value_ ? "true" : "false"; }

    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 boolean parse(const string_view lower) {
        boolean obj;
        string str(lower.trim());
        try {
            str.lowercase();
            if (str == "true" || str == "yes" || str == "y") {
                obj = true;
            } else if (str == "false" || str == "no" || str == "n") {
                obj = false;
            } else {
                obj = static_cast<bool>(to_int32(str.view(), nullptr, 10));
            }
        } catch (...) {
            NEFORCE_THROW_EXCEPTION(typecast_exception("Convert from string to boolean failed."));
        }
        return obj;
    }

    constexpr boolean operator!() const noexcept { return boolean(!value_); }
};
 
template <>
struct package<bool> {
    using type = boolean;
};
 
template <>
struct unpackage<boolean> {
    using type = bool;
};
 
 
#define __NEFORCE_BUILD_INTEGER_STRUCT(SIGN, UPPER, BYTE)                                                           \
    struct SIGN##integer##BYTE : iobject<SIGN##integer##BYTE>, ipackage<SIGN##integer##BYTE, SIGN##int##BYTE##_t> { \
        using value_type = SIGN##int##BYTE##_t;                                                                     \
        using base = ipackage<SIGN##integer##BYTE, SIGN##int##BYTE##_t>;                                            \
                                                                                                                    \
        constexpr SIGN##integer##BYTE() noexcept = default;                                                         \
        NEFORCE_CONSTEXPR20 ~SIGN##integer##BYTE() = default;                                                       \
                                                                                                                    \
        constexpr SIGN##integer##BYTE(const SIGN##integer##BYTE&) noexcept = default;                               \
        constexpr SIGN##integer##BYTE(SIGN##integer##BYTE&&) noexcept = default;                                    \
                                                                                                                    \
        constexpr SIGN##integer##BYTE& operator=(const SIGN##integer##BYTE& other) noexcept = default;              \
        constexpr SIGN##integer##BYTE& operator=(SIGN##integer##BYTE&& other) noexcept = default;                   \
                                                                                                                    \
        explicit constexpr SIGN##integer##BYTE(const value_type value) noexcept :                                   \
        base(value) {}                                                                                              \
                                                                                                                    \
        constexpr SIGN##integer##BYTE& operator=(const value_type value) noexcept {                                 \
            value_ = value;                                                                                         \
            return *this;                                                                                           \
        }                                                                                                           \
                                                                                                                    \
        NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept {                                       \
            return value_ != _NEFORCE initialize<value_type>();                                                     \
        }                                                                                                           \
                                                                                                                    \
        NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {                     \
            return inner::__int_to_string_dispatch(value);                                                          \
        }                                                                                                           \
                                                                                                                    \
        NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const {                                            \
            return inner::__int_to_string_dispatch(value_);                                                         \
        }                                                                                                           \
                                                                                                                    \
        NEFORCE_NODISCARD static constexpr SIGN##integer##BYTE parse(const string_view str) {                       \
            return SIGN##integer##BYTE{_NEFORCE to_##SIGN##int##BYTE(str)};                                         \
        }                                                                                                           \
    };                                                                                                              \
    template <>                                                                                                     \
    struct package<SIGN##int##BYTE##_t> {                                                                           \
        using type = SIGN##integer##BYTE;                                                                           \
    };                                                                                                              \
    template <>                                                                                                     \
    struct unpackage<SIGN##integer##BYTE> {                                                                         \
        using type = SIGN##int##BYTE##_t;                                                                           \
    };

__NEFORCE_BUILD_INTEGER_STRUCT(, , 8)
 

__NEFORCE_BUILD_INTEGER_STRUCT(, , 16)

__NEFORCE_BUILD_INTEGER_STRUCT(, , 32)

__NEFORCE_BUILD_INTEGER_STRUCT(, , 64)

__NEFORCE_BUILD_INTEGER_STRUCT(u, U, 8)

__NEFORCE_BUILD_INTEGER_STRUCT(u, U, 16)

__NEFORCE_BUILD_INTEGER_STRUCT(u, U, 32)

__NEFORCE_BUILD_INTEGER_STRUCT(u, U, 64)
 
#undef __NEFORCE_BUILD_INTEGER_STRUCT

using byte = uinteger8;
 
 
#ifdef NEFORCE_PLATFORM_LINUX64
template <>
struct package<long long> {
    using type = integer64;
};
template <>
struct package<unsigned long long> {
    using type = uinteger64;
};
#else
template <>
struct package<long> {
    using type = integer32;
};
template <>
struct package<unsigned long> {
    using type = uinteger32;
};
#endif
 

struct uinteger128 : iobject<uinteger128>, ipackage<uinteger128, uint128_t> {
    using value_type = uint128_t;
    using base = ipackage<uinteger128, uint128_t>;
 
    constexpr uinteger128() noexcept = default;
    NEFORCE_CONSTEXPR20 ~uinteger128() = default;
 
    constexpr uinteger128(const uinteger128&) noexcept = default;
    constexpr uinteger128(uinteger128&&) noexcept = default;
 
    constexpr uinteger128& operator=(const uinteger128& other) noexcept = default;
    constexpr uinteger128& operator=(uinteger128&& other) noexcept = default;

    explicit constexpr uinteger128(const value_type value) noexcept :
    base(value) {}

    constexpr uinteger128& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    explicit NEFORCE_CONSTEXPR20 uinteger128(const string& str, const int base = 10) :
    uinteger128(str.view(), base) {}

    explicit constexpr uinteger128(string_view str, int base = 10);
 
    NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept { return value_ != value_type(); }

    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {
        return inner::__int_to_string_dispatch(value);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return inner::__int_to_string_dispatch(value_); }

    NEFORCE_NODISCARD static constexpr uinteger128 parse(const string_view str) {
        return uinteger128{_NEFORCE to_uint128(str)};
    }

    constexpr uinteger128& operator<<=(const uint32_t shift) noexcept {
        value_ <<= shift;
        return *this;
    }

    constexpr uinteger128& operator>>=(const uint32_t shift) noexcept {
        value_ >>= shift;
        return *this;
    }
};

struct integer128 : iobject<integer128>, ipackage<integer128, int128_t> {
    using value_type = int128_t;
    using base = ipackage<integer128, int128_t>;
 
    constexpr integer128() noexcept = default;
    NEFORCE_CONSTEXPR20 ~integer128() = default;
 
    constexpr integer128(const integer128&) noexcept = default;
    constexpr integer128(integer128&&) noexcept = default;
 
    constexpr integer128& operator=(const integer128& other) noexcept = default;
    constexpr integer128& operator=(integer128&& other) noexcept = default;

    explicit constexpr integer128(const value_type value) noexcept :
    base(value) {}

    constexpr integer128& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }

    explicit NEFORCE_CONSTEXPR20 integer128(const string& str, const int base = 10) :
    integer128(str.view(), base) {}

    explicit constexpr integer128(const string_view str, const int base = 10);
 
    NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept { return value_ != value_type(); }

    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {
        return inner::__int_to_string_dispatch(value);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return inner::__int_to_string_dispatch(value_); }

    NEFORCE_NODISCARD static constexpr integer128 parse(const string_view str) {
        return integer128{_NEFORCE to_int128(str)};
    }

    constexpr integer128& operator<<=(const uint32_t shift) noexcept {
        ignore = value_ <<= shift;
        return *this;
    }

    constexpr integer128& operator>>=(const uint32_t shift) noexcept {
        ignore = value_ >>= shift;
        return *this;
    }
};
 
constexpr uinteger128::uinteger128(const string_view str, const int base) {
    *this = uinteger128{to_uint128(str, nullptr, base)};
}
 
constexpr integer128::integer128(const string_view str, const int base) {
    *this = integer128{to_int128(str, nullptr, base)};
}
 
template <>
struct package<uint128_t> {
    using type = uinteger128;
};
 
template <>
struct unpackage<uinteger128> {
    using type = uint128_t;
};
 
template <>
struct package<int128_t> {
    using type = integer128;
};
 
template <>
struct unpackage<integer128> {
    using type = int128_t;
};
 

struct float32 : iobject<float32>, ipackage<float32, float32_t> {
    using value_type = float32_t;
    using base = ipackage<float32, float32_t>;
 
    constexpr float32() noexcept = default;
    NEFORCE_CONSTEXPR20 ~float32() = default;
 
    constexpr float32(const float32&) noexcept = default;
    constexpr float32(float32&&) noexcept = default;
 
    constexpr float32& operator=(const float32& other) noexcept = default;
    constexpr float32& operator=(float32&& other) noexcept = default;
 
    explicit constexpr float32(const value_type value) noexcept :
    base(value) {}
 
    constexpr float32& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }
 
    NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept {
        return value_ != _NEFORCE initialize<value_type>();
    }
 
    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {
        return float32(value).to_string();
    }
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return inner::__float_to_string<char>(value_); }
 
    NEFORCE_NODISCARD static constexpr float32 parse(const string_view str) {
        return float32{_NEFORCE to_float32(str)};
    }
};
 
template <>
struct package<float32_t> {
    using type = float32;
};
 
template <>
struct unpackage<float32> {
    using type = float32_t;
};
 

struct float64 : iobject<float64>, ipackage<float64, float64_t> {
    using value_type = float64_t;
    using base = ipackage<float64, float64_t>;
 
    constexpr float64() noexcept = default;
    NEFORCE_CONSTEXPR20 ~float64() = default;
 
    constexpr float64(const float64&) noexcept = default;
    constexpr float64(float64&&) noexcept = default;
 
    constexpr float64& operator=(const float64& other) noexcept = default;
    constexpr float64& operator=(float64&& other) noexcept = default;
 
    explicit constexpr float64(const value_type value) noexcept :
    base(value) {}
 
    constexpr float64& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }
 
    NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept {
        return value_ != _NEFORCE initialize<value_type>();
    }
 
    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {
        return float64(value).to_string();
    }
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return inner::__float_to_string<char>(value_); }
 
    NEFORCE_NODISCARD static constexpr float64 parse(const string_view str) {
        return float64{_NEFORCE to_float64(str)};
    }
};
 
template <>
struct package<float64_t> {
    using type = float64;
};
 
template <>
struct unpackage<float64> {
    using type = float64_t;
};
 

struct decimal : iobject<decimal>, ipackage<decimal, decimal_t> {
    using value_type = decimal_t;
    using base = ipackage<decimal, decimal_t>;
 
    constexpr decimal() noexcept = default;
    NEFORCE_CONSTEXPR20 ~decimal() = default;
 
    constexpr decimal(const decimal&) noexcept = default;
    constexpr decimal(decimal&&) noexcept = default;
 
    constexpr decimal& operator=(const decimal& other) noexcept = default;
    constexpr decimal& operator=(decimal&& other) noexcept = default;
 
    explicit constexpr decimal(const value_type value) noexcept :
    base(value) {}
 
    constexpr decimal& operator=(const value_type value) noexcept {
        value_ = value;
        return *this;
    }
 
    NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept {
        return value_ != _NEFORCE initialize<value_type>();
    }
 
    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 string to_string(const value_type value) {
        return decimal(value).to_string();
    }
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return inner::__float_to_string<char>(value_); }
 
    NEFORCE_NODISCARD static constexpr decimal parse(const string_view str) {
        return decimal{_NEFORCE to_decimal(str)};
    }
};
 
template <>
struct package<decimal_t> {
    using type = decimal;
};
 
template <>
struct unpackage<decimal> {
    using type = decimal_t;
};
 // Packages
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_PACKAGES_HPP__