byte_size.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_BYTE_SIZE_HPP__
#define NEFORCE_CORE_UTILITY_BYTE_SIZE_HPP__

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


class NEFORCE_API byte_size : public iobject<byte_size>, public icommon<byte_size> {
public:
    enum class unit {
        AUTO, 
        B,    
        KB,   
        MB,   
        GB,   
        TB,   
        PB,   
        EB    
    };
 
private:
    uint64_t bytes_{0}; 
 
public:
    constexpr byte_size() = default;

    constexpr explicit byte_size(uint64_t bytes) :
    bytes_(bytes) {}

    byte_size(decimal_t value, unit u, bool binary = true);

    NEFORCE_NODISCARD static byte_size parse(string_view str) { return parse(str, true); }

    NEFORCE_NODISCARD static byte_size parse(string_view str, bool binary);

    NEFORCE_NODISCARD constexpr uint64_t bytes() const { return bytes_; }

    NEFORCE_NODISCARD decimal_t as(unit u, bool binary = true) const;

    NEFORCE_NODISCARD string to_string() const { return to_string(unit::AUTO, 2, true); }

    NEFORCE_NODISCARD string to_string(unit u, int precision = 2, bool binary = true) const;

    NEFORCE_NODISCARD constexpr bool is_zero() const noexcept { return bytes_ == 0; }
 
    byte_size& operator+=(const byte_size& rhs) {
        bytes_ += rhs.bytes_;
        return *this;
    }
 
    byte_size& operator-=(const byte_size& rhs) {
        if (bytes_ < rhs.bytes_) {
            NEFORCE_THROW_EXCEPTION(value_exception("Memory size subtraction underflow"));
        }
        bytes_ -= rhs.bytes_;
        return *this;
    }
 
    byte_size& operator*=(uint64_t factor) {
        bytes_ *= factor;
        return *this;
    }
 
    byte_size& operator/=(uint64_t divisor) {
        if (divisor == 0) {
            NEFORCE_THROW_EXCEPTION(value_exception("Division by zero"));
        }
        bytes_ /= divisor;
        return *this;
    }
 
    NEFORCE_NODISCARD constexpr byte_size operator+(const byte_size& rhs) const noexcept {
        return byte_size(bytes_ + rhs.bytes_);
    }
 
    NEFORCE_NODISCARD byte_size operator-(const byte_size& rhs) const {
        if (bytes_ < rhs.bytes_) {
            NEFORCE_THROW_EXCEPTION(value_exception("Memory size subtraction underflow"));
        }
        return byte_size(bytes_ - rhs.bytes_);
    }
 
    NEFORCE_NODISCARD byte_size operator*(uint64_t factor) const {
        if (factor > 0 && bytes_ > numeric_traits<uint64_t>::max() / factor) {
            NEFORCE_THROW_EXCEPTION(value_exception("Memory size multiplication overflow"));
        }
        return byte_size(bytes_ * factor);
    }
 
    NEFORCE_NODISCARD byte_size operator/(uint64_t divisor) const {
        if (divisor == 0) {
            NEFORCE_THROW_EXCEPTION(value_exception("Division by zero"));
        }
        return byte_size(bytes_ / divisor);
    }
 
    NEFORCE_NODISCARD friend byte_size operator*(uint64_t factor, const byte_size& size) { return size * factor; }
 
    NEFORCE_NODISCARD bool operator==(const byte_size& rhs) const { return bytes_ == rhs.bytes_; }
    NEFORCE_NODISCARD bool operator<(const byte_size& rhs) const { return bytes_ < rhs.bytes_; }

    NEFORCE_NODISCARD size_t to_hash() const noexcept { return hash<uint64_t>()(bytes_); }
};
 
template <>
struct unpackage<byte_size> {
    using type = uint64_t;
};
 // ByteSize
 
NEFORCE_BEGIN_LITERALS__


NEFORCE_NODISCARD inline byte_size operator""_B(const uint64_t bytes) noexcept { return byte_size{bytes}; }

NEFORCE_NODISCARD inline byte_size operator""_B(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::B};
}

NEFORCE_NODISCARD inline byte_size operator""_KB(const uint64_t bytes) noexcept {
    return byte_size{static_cast<decimal_t>(bytes), byte_size::unit::KB};
}

NEFORCE_NODISCARD inline byte_size operator""_KB(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::KB};
}

NEFORCE_NODISCARD inline byte_size operator""_MB(const uint64_t bytes) noexcept {
    return byte_size{static_cast<decimal_t>(bytes), byte_size::unit::MB};
}

NEFORCE_NODISCARD inline byte_size operator""_MB(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::MB};
}

NEFORCE_NODISCARD inline byte_size operator""_GB(const uint64_t bytes) noexcept {
    return byte_size{static_cast<decimal_t>(bytes), byte_size::unit::GB};
}

NEFORCE_NODISCARD inline byte_size operator""_GB(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::GB};
}

NEFORCE_NODISCARD inline byte_size operator""_TB(const uint64_t bytes) noexcept {
    return byte_size{static_cast<decimal_t>(bytes), byte_size::unit::TB};
}

NEFORCE_NODISCARD inline byte_size operator""_TB(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::TB};
}

NEFORCE_NODISCARD inline byte_size operator""_PB(const uint64_t bytes) noexcept {
    return byte_size{static_cast<decimal_t>(bytes), byte_size::unit::PB};
}

NEFORCE_NODISCARD inline byte_size operator""_PB(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::PB};
}

NEFORCE_NODISCARD inline byte_size operator""_EB(const uint64_t bytes) noexcept {
    return byte_size{static_cast<decimal_t>(bytes), byte_size::unit::EB};
}

NEFORCE_NODISCARD inline byte_size operator""_EB(const decimal_t bytes) noexcept {
    return byte_size{bytes, byte_size::unit::EB};
}
 // UserLiterals
 
NEFORCE_END_LITERALS__
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_BYTE_SIZE_HPP__