size.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte.
 *
 * StormByte original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte source in this repository.
 * They do not cover other StormByte modules or any third-party material
 * shipped with this repository (including everything under thirdparty/),
 * which remains under its own license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * StormByte is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with StormByte. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/cstring.hxx>
#include <StormByte/type_traits.hxx>
#include <StormByte/visibility.h>
 
#include <cassert>
#include <compare>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <ostream>
#include <string>
 
namespace StormByte {
    class STORMBYTE_PUBLIC Size {
        public:
            constexpr Size() noexcept: m_value(0) {}
 
            template<Type::Integral T>
            constexpr Size(T value) noexcept: m_value(0) {
                if constexpr (Type::Signed<T>)
                    assert(value >= static_cast<T>(0));
                m_value = static_cast<std::uint64_t>(value);
            }
 
            constexpr Size(const Size& other) noexcept = default;
 
            constexpr Size(Size&& other) noexcept = default;
 
            constexpr ~Size() noexcept = default;
 
            constexpr Size& operator=(const Size& other) noexcept = default;
 
            constexpr Size& operator=(Size&& other) noexcept = default;
 
            template<Type::Integral T>
            constexpr Size& operator=(T value) noexcept {
                *this = Size(value);
                return *this;
            }
 
            constexpr std::uint64_t Value() const noexcept {
                return m_value;
            }
 
            constexpr explicit operator std::uint64_t() const noexcept {
                return m_value;
            }
 
            template<typename T>
            requires Type::SameAs<T, std::size_t> && (!Type::SameAs<std::size_t, std::uint64_t>)
            constexpr explicit operator T() const noexcept {
                assert(m_value <= static_cast<std::uint64_t>(std::numeric_limits<std::size_t>::max()));
                return static_cast<std::size_t>(m_value);
            }
 
            constexpr explicit operator std::ptrdiff_t() const noexcept {
                assert(m_value <= static_cast<std::uint64_t>(std::numeric_limits<std::ptrdiff_t>::max()));
                return static_cast<std::ptrdiff_t>(m_value);
            }
 
            explicit operator CString() const noexcept;
 
            inline operator std::string() const {
                return static_cast<std::string>(static_cast<CString>(*this));
            }
 
            friend constexpr bool operator==(Size lhs, Size rhs) noexcept {
                return lhs.m_value == rhs.m_value;
            }
 
            friend constexpr std::strong_ordering operator<=>(Size lhs, Size rhs) noexcept {
                return lhs.m_value <=> rhs.m_value;
            }
 
            friend constexpr Size operator+(Size lhs, Size rhs) noexcept {
                assert(lhs.m_value <= std::numeric_limits<std::uint64_t>::max() - rhs.m_value);
                return Size(static_cast<std::uint64_t>(lhs.m_value + rhs.m_value));
            }
 
            friend constexpr Size operator-(Size lhs, Size rhs) noexcept {
                assert(lhs.m_value >= rhs.m_value);
                return Size(static_cast<std::uint64_t>(lhs.m_value - rhs.m_value));
            }
 
            constexpr Size& operator+=(Size other) noexcept {
                *this = *this + other;
                return *this;
            }
 
            constexpr Size& operator-=(Size other) noexcept {
                *this = *this - other;
                return *this;
            }
 
        private:
            std::uint64_t m_value;  
    };
 
    struct Unit {
        std::uint64_t factor;   
    };
 
    inline constexpr Unit B{1};             
    inline constexpr Unit KiB{1024};            
    inline constexpr Unit MiB{1024ull * 1024};      
    inline constexpr Unit GiB{1024ull * 1024 * 1024};   
    inline constexpr Unit TiB{1024ull * 1024 * 1024 * 1024};            
    inline constexpr Unit PiB{1024ull * 1024 * 1024 * 1024 * 1024};     
    inline constexpr Unit EiB{1024ull * 1024 * 1024 * 1024 * 1024 * 1024};  
    inline constexpr Unit KB{1000};             
    inline constexpr Unit MB{1000ull * 1000};       
    inline constexpr Unit GB{1000ull * 1000 * 1000};    
    inline constexpr Unit TB{1000ull * 1000 * 1000 * 1000};         
    inline constexpr Unit PB{1000ull * 1000 * 1000 * 1000 * 1000};      
    inline constexpr Unit EB{1000ull * 1000 * 1000 * 1000 * 1000 * 1000};   
    template<Type::Integral T>
    constexpr Size operator*(T count, Unit unit) noexcept {
        if constexpr (Type::Signed<T>)
            assert(count >= T{0});
        const std::uint64_t factor = static_cast<std::uint64_t>(count);
        assert(unit.factor == 0 || factor <= std::numeric_limits<std::uint64_t>::max() / unit.factor);
        return Size(factor * unit.factor);
    }
 
    template<Type::Integral T>
    constexpr Size operator*(Unit unit, T count) noexcept {
        return count * unit;
    }
 
    template<Type::FloatingPoint T>
    constexpr Size operator*(T count, Unit unit) noexcept {
        assert(count >= T{0});
        const long double product = static_cast<long double>(count) * static_cast<long double>(unit.factor);
        assert(product <= static_cast<long double>(std::numeric_limits<std::uint64_t>::max()));
        return Size(static_cast<std::uint64_t>(product + 0.5L));
    }
 
    template<Type::FloatingPoint T>
    constexpr Size operator*(Unit unit, T count) noexcept {
        return count * unit;
    }
 
    template<Type::Integral T>
    constexpr Size operator*(T count, const Size& size) noexcept {
        if constexpr (Type::Signed<T>)
            assert(count > T{0});
        else
            assert(count != T{0});
        const std::uint64_t factor = static_cast<std::uint64_t>(count);
        assert(size.Value() == 0 || factor <= std::numeric_limits<std::uint64_t>::max() / size.Value());
        return Size(factor * size.Value());
    }
 
    template<Type::Integral T>
    constexpr Size operator*(const Size& size, T count) noexcept {
        return count * size;
    }
 
    template<Type::Integral T>
    constexpr std::uint64_t operator/(const Size& size, T count) noexcept {
        if constexpr (Type::Signed<T>)
            assert(count > T{0});
        else
            assert(count != T{0});
        return size.Value() / static_cast<std::uint64_t>(count);
    }
 
    template<Type::Integral T>
    constexpr std::uint64_t operator%(const Size& size, T count) noexcept {
        if constexpr (Type::Signed<T>)
            assert(count > T{0});
        else
            assert(count != T{0});
        return size.Value() % static_cast<std::uint64_t>(count);
    }
 
    inline std::ostream& operator<<(std::ostream& stream, const Size& size) {
        return stream << static_cast<std::string>(size);
    }
}