integer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_VALUE_INTEGER_H
#define pRC_CORE_VALUE_INTEGER_H
 
#include <prc/core/basic/functions/identity.hpp>
#include <prc/core/basic/functions/unit.hpp>
#include <prc/core/basic/functions/zero.hpp>
#include <prc/core/functors/add.hpp>
#include <prc/core/functors/div.hpp>
#include <prc/core/functors/mod.hpp>
#include <prc/core/functors/mul.hpp>
#include <prc/core/functors/sub.hpp>
#include <prc/core/log/log.hpp>
#include <prc/core/value/value.hpp>
 
namespace pRC
{
    template<Bool S, Size W>
    class Integer
    {
    public:
        using Fundamental = Conditional<S,
            Conditional<W == 8, std::int8_t,
                Conditional<W == 16, std::int16_t,
                    Conditional<W == 32, std::int32_t,
                        Conditional<W == 64, std::int64_t, Undefined>>>>,
            Conditional<W == 8, std::uint8_t,
                Conditional<W == 16, std::uint16_t,
                    Conditional<W == 32, std::uint32_t,
                        Conditional<W == 64, std::uint64_t, Undefined>>>>>;
 
        static constexpr Size Width = W;
        template<Size C>
        using ChangeSize = Float<C>;
 
        static constexpr Bool Signed = S;
        template<Bool C>
        using ChangeSigned = Integer<C, W>;
 
    public:
        ~Integer()
            requires IsDefined<Fundamental>
        = default;
        constexpr Integer(Integer const &) = default;
        constexpr Integer(Integer &&) = default;
        constexpr Integer &operator=(Integer const &) & = default;
        constexpr Integer &operator=(Integer &&) & = default;
        constexpr Integer() = default;
 
        template<class U>
            requires IsConstructible<Fundamental, U>
        constexpr Integer(U const basic)
            : mValue(basic)
        {
        }
 
        template<IsValue U>
        constexpr Integer(U const &value)
            : mValue(value())
        {
        }
 
        constexpr Integer(Zero<> const)
            : Integer(zero<Integer>())
        {
        }
 
        constexpr Integer(Unit<> const)
            : Integer(unit<Integer>())
        {
        }
 
        constexpr Integer(Identity<> const)
            : Integer(identity<Integer>())
        {
        }
 
        template<class U>
            requires IsAssignable<Fundamental, U>
        constexpr auto &operator=(U const basic) &
        {
            mValue = basic;
            return *this;
        }
 
        template<IsValue U>
        constexpr auto &operator=(U const &value) &
        {
            mValue = value();
            return *this;
        }
 
        constexpr auto &operator=(Zero<> const) &
        {
            return *this = zero<Integer>();
        }
 
        constexpr auto &operator=(Unit<> const) &
        {
            return *this = unit<Integer>();
        }
 
        constexpr auto &operator=(Identity<> const) &
        {
            return *this = identity<Integer>();
        }
 
        constexpr decltype(auto) operator()() &&
        {
            return move(mValue);
        }
 
        constexpr decltype(auto) operator()() const &&
        {
            return move(mValue);
        }
 
        constexpr auto &operator()() &
        {
            return mValue;
        }
 
        constexpr auto &operator()() const &
        {
            return mValue;
        }
 
        explicit constexpr operator Fundamental() const
        {
            return mValue;
        }
 
        template<class X>
            requires IsInvocable<Add, Integer &, X>
        constexpr auto &operator+=(X &&rhs) &
        {
            return *this = *this + forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Sub, Integer &, X>
        constexpr auto &operator-=(X &&rhs) &
        {
            return *this = *this - forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Mul, Integer &, X>
        constexpr auto &operator*=(X &&rhs) &
        {
            return *this = *this * forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Div, Integer &, X>
        constexpr auto &operator/=(X &&rhs) &
        {
            return *this = *this / forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Mod, Integer &, X>
        constexpr auto &operator%=(X &&rhs) &
        {
            return *this = *this % forward<X>(rhs);
        }
 
    private:
        Fundamental mValue;
    };
 
    Integer(Integer<true, 8>::Fundamental const) -> Integer<true, 8>;
    Integer(Integer<true, 16>::Fundamental const) -> Integer<true, 16>;
    Integer(Integer<true, 32>::Fundamental const) -> Integer<true, 32>;
    Integer(Integer<true, 64>::Fundamental const) -> Integer<true, 64>;
    Integer(Integer<false, 8>::Fundamental const) -> Integer<false, 8>;
    Integer(Integer<false, 16>::Fundamental const) -> Integer<false, 16>;
    Integer(Integer<false, 32>::Fundamental const) -> Integer<false, 32>;
    Integer(Integer<false, 64>::Fundamental const) -> Integer<false, 64>;
}
#endif // pRC_CORE_VALUE_INTEGER_H