ipackage.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_INTERFACE_IPACKAGE_HPP__
#define NEFORCE_CORE_INTERFACE_IPACKAGE_HPP__

 
#include "NeForce/core/interface/icommon.hpp"
#include "NeForce/core/interface/inumeric.hpp"
#include "NeForce/core/numeric/math.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T, typename PackageT>
struct ipackage : icommon<T>, iarithmetic<T>, ibinary<T> {
    static_assert(is_arithmetic_v<PackageT>, "PackageT must be arithmetic.");
 
private:
    constexpr const T& derived() const noexcept { return static_cast<const T&>(*this); }

    constexpr T& derived() noexcept { return static_cast<T&>(*this); }
 
public:
    using package_type = PackageT; 
 
protected:
    package_type value_{static_cast<package_type>(0)}; 
 
public:
    constexpr ipackage() noexcept = default;
 
    constexpr ipackage(const ipackage& other) noexcept = default;
    constexpr ipackage(ipackage&& other) noexcept = default;
 
    constexpr ipackage& operator=(const ipackage& other) noexcept = default;
    constexpr ipackage& operator=(ipackage&& other) noexcept = default;

    explicit constexpr ipackage(package_type value) noexcept :
    value_(value) {}
 
protected:
    NEFORCE_CONSTEXPR20 ~ipackage() = default;
 
public:
    NEFORCE_NODISCARD explicit constexpr operator package_type() const noexcept { return value_; }

    NEFORCE_NODISCARD constexpr package_type value() const noexcept { return value_; }

    NEFORCE_NODISCARD constexpr int64_t to_int64() const noexcept { return static_cast<int64_t>(value_); }

    NEFORCE_NODISCARD static constexpr size_t bytes() noexcept { return sizeof(package_type); }

    NEFORCE_NODISCARD static constexpr size_t bits() noexcept { return sizeof(package_type) * 8; }

    NEFORCE_NODISCARD constexpr size_t to_hash() const noexcept { return _NEFORCE hash<package_type>()(value_); }

    constexpr void swap(T& other) noexcept { _NEFORCE swap(value_, other.value_); }

    NEFORCE_NODISCARD constexpr bool operator==(const T& other) const noexcept { return value_ == other.value_; }

    NEFORCE_NODISCARD constexpr bool operator<(const T& other) const noexcept { return value_ < other.value_; }

    constexpr T& operator+=(const T& other) noexcept {
        value_ += other.value_;
        return derived();
    }

    constexpr T& operator-=(const T& other) noexcept {
        value_ -= other.value_;
        return derived();
    }

    constexpr T& operator*=(const T& other) noexcept {
        value_ *= other.value_;
        return derived();
    }

    constexpr T& operator/=(const T& other) {
        if (other.value_ == 0) {
            NEFORCE_THROW_EXCEPTION(math_exception("Division by zero"));
        }
        value_ /= other.value_;
        return derived();
    }

    constexpr T& operator%=(const T& other) {
        value_ = _NEFORCE mod(value_, other.value_);
        return derived();
    }

    NEFORCE_NODISCARD constexpr T operator-() const noexcept { return T(-value_); }

    constexpr T& operator++() noexcept {
        ++value_;
        return derived();
    }

    constexpr T& operator--() noexcept {
        --value_;
        return derived();
    }

    constexpr T operator~() const noexcept { return T{~value_}; }

    constexpr T& operator&=(const T& other) noexcept {
        value_ &= other.value_;
        return derived();
    }

    constexpr T& operator|=(const T& other) noexcept {
        value_ |= other.value_;
        return derived();
    }

    constexpr T& operator^=(const T& other) noexcept {
        value_ ^= other.value_;
        return derived();
    }

    constexpr T& operator<<=(const uint32_t shift) {
        if (shift >= 64) {
            NEFORCE_THROW_EXCEPTION(value_exception("Shift count out of range"));
        }
        value_ <<= shift;
        return derived();
    }

    constexpr T& operator>>=(const uint32_t shift) {
        if (shift >= 64) {
            NEFORCE_THROW_EXCEPTION(value_exception("Shift count out of range"));
        }
        value_ >>= shift;
        return derived();
    }
};
 // CRTPInterfaces
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_INTERFACE_IPACKAGE_HPP__