npint.hpp

/*
 * This file is part of libtcspc
 * Copyright 2019-2026 Board of Regents of the University of Wisconsin System
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
 
#include "int_types.hpp"
 
#include <compare>
#include <concepts>
#include <istream>
#include <limits>
#include <ostream>
#include <type_traits>
 
namespace tcspc {

template <std::integral T> class npint {
    T v;
 
  public:
    using underlying_type = T;
 
    // Rule of zero

    constexpr npint() noexcept = default;

    explicit constexpr npint(T value) noexcept : v(value) {}

    explicit constexpr operator T() const noexcept { return v; }

    [[nodiscard]] constexpr auto value() const noexcept -> T { return v; }

    template <typename U>
        requires(not std::same_as<T, U>)
    explicit constexpr npint(npint<U> const &other) : v(T(other.value())) {
        static_assert(
            sizeof(T) <= sizeof(U) ||
                std::is_unsigned_v<T> == std::is_unsigned_v<U>,
            "Widening and changing signedness at the same time is not allowed");
    }
 
    // Operators
 
    // The following operators are intentionally left out:
    // ! && ||
    // because we do not want to automatically treat a number as a boolean.
 
    // Increment and decrement operators

    constexpr auto operator++() -> npint { return npint(++v); }

    constexpr auto operator++(int) -> npint { return npint(v++); }

    constexpr auto operator--() -> npint { return npint(--v); }

    constexpr auto operator--(int) -> npint { return npint(v--); }
 
    // Compound assignment operators

    constexpr auto operator+=(npint rhs) -> npint & {
        v += rhs.v;
        return *this;
    }

    constexpr auto operator-=(npint rhs) -> npint & {
        v -= rhs.v;
        return *this;
    }

    constexpr auto operator*=(npint rhs) -> npint & {
        v *= rhs.v;
        return *this;
    }

    constexpr auto operator/=(npint rhs) -> npint & {
        v /= rhs.v;
        return *this;
    }

    constexpr auto operator%=(npint rhs) -> npint & {
        v %= rhs.v;
        return *this;
    }

    constexpr auto operator&=(npint rhs) noexcept -> npint & {
        v &= rhs.v;
        return *this;
    }

    constexpr auto operator|=(npint rhs) noexcept -> npint & {
        v |= rhs.v;
        return *this;
    }

    constexpr auto operator^=(npint rhs) noexcept -> npint & {
        v ^= rhs.v;
        return *this;
    }

    template <typename U> constexpr auto operator>>=(npint<U> rhs) -> npint & {
        v = static_cast<T>(v >> rhs.value());
        return *this;
    }

    template <typename U> constexpr auto operator<<=(npint<U> rhs) -> npint & {
        v = static_cast<T>(v << rhs.value());
        return *this;
    }

    constexpr auto operator>>=(std::integral auto rhs) -> npint & {
        v = static_cast<T>(v >> rhs);
        return *this;
    }

    constexpr auto operator<<=(std::integral auto rhs) -> npint & {
        v = static_cast<T>(v << rhs);
        return *this;
    }
 
    // Unary arithmetic operators

    constexpr auto operator+() const noexcept -> npint { return *this; }

    constexpr auto operator-() const -> npint {
        return npint(static_cast<T>(-v));
    }
 
    // Binary arithmetic operators

    friend constexpr auto operator+(npint lhs, npint rhs) -> npint {
        return lhs += rhs;
    }

    friend constexpr auto operator-(npint lhs, npint rhs) -> npint {
        return lhs -= rhs;
    }

    friend constexpr auto operator*(npint lhs, npint rhs) -> npint {
        return lhs *= rhs;
    }

    friend constexpr auto operator/(npint lhs, npint rhs) -> npint {
        return lhs /= rhs;
    }

    friend constexpr auto operator%(npint lhs, npint rhs) -> npint {
        return lhs %= rhs;
    }
 
    // Bitwise arithmetic operators

    friend constexpr auto operator&(npint lhs, npint rhs) noexcept -> npint {
        return lhs &= rhs;
    }

    friend constexpr auto operator|(npint lhs, npint rhs) noexcept -> npint {
        return lhs |= rhs;
    }

    friend constexpr auto operator^(npint lhs, npint rhs) noexcept -> npint {
        return lhs ^= rhs;
    }

    constexpr auto operator~() const noexcept -> npint {
        return npint(static_cast<T>(~v));
    }

    template <typename U>
    friend constexpr auto operator<<(npint lhs, npint<U> rhs) -> npint {
        return lhs <<= rhs;
    }

    template <typename U>
    friend constexpr auto operator>>(npint lhs, npint<U> rhs) -> npint {
        return lhs >>= rhs;
    }

    friend constexpr auto operator<<(npint lhs, std::integral auto rhs)
        -> npint {
        return lhs <<= rhs;
    }

    friend constexpr auto operator>>(npint lhs, std::integral auto rhs)
        -> npint {
        return lhs >>= rhs;
    }
 
    // Binary comparison operators

    friend constexpr auto operator<=>(npint lhs, npint rhs) noexcept
        -> std::strong_ordering = default;
 
    // Stream insertion and extraction operators

    friend auto operator<<(std::ostream &strm, npint rhs) -> std::ostream & {
        return strm << rhs.v;
    }

    friend auto operator>>(std::istream &strm, npint &rhs) -> std::istream & {
        return strm >> rhs.v;
    }
};

using u8np = npint<u8>;

using u16np = npint<u16>;

using u32np = npint<u32>;

using u64np = npint<u64>;

using i8np = npint<i8>;

using i16np = npint<i16>;

using i32np = npint<i32>;

using i64np = npint<i64>;

namespace literals {

constexpr auto operator""_u8np(unsigned long long v) -> u8np {
    return u8np(u8(v));
}

constexpr auto operator""_u16np(unsigned long long v) -> u16np {
    return u16np(u16(v));
}

constexpr auto operator""_u32np(unsigned long long v) -> u32np {
    return u32np(u32(v));
}

constexpr auto operator""_u64np(unsigned long long v) -> u64np {
    return u64np(v);
}

constexpr auto operator""_i8np(unsigned long long v) -> i8np {
    return v <= u8(std::numeric_limits<i8>::max()) ? i8np(static_cast<i8>(v))
                                                   : throw;
}

constexpr auto operator""_i16np(unsigned long long v) -> i16np {
    return v <= u16(std::numeric_limits<i16>::max())
               ? i16np(static_cast<i16>(v))
               : throw;
}

constexpr auto operator""_i32np(unsigned long long v) -> i32np {
    return v <= u32(std::numeric_limits<i32>::max())
               ? i32np(static_cast<i32>(v))
               : throw;
}

constexpr auto operator""_i64np(unsigned long long v) -> i64np {
    return v <= u64(std::numeric_limits<i64>::max())
               ? i64np(static_cast<i64>(v))
               : throw;
}
 
} // namespace literals
 
using namespace literals;
 
} // namespace tcspc
 
namespace std {
 
// NOLINTNEXTLINE(cert-dcl58-cpp)
template <typename T> struct numeric_limits<tcspc::npint<T>> {
    static constexpr bool is_specialized = true;
 
    static constexpr bool has_denorm_loss = numeric_limits<T>::has_denorm_loss;
    static constexpr bool has_infinity = numeric_limits<T>::has_infinity;
    static constexpr bool has_quiet_NaN = numeric_limits<T>::has_quiet_NaN;
    static constexpr bool has_signaling_NaN =
        numeric_limits<T>::has_signaling_NaN;
    static constexpr bool is_bounded = numeric_limits<T>::is_bounded;
    static constexpr bool is_exact = numeric_limits<T>::is_exact;
    static constexpr bool is_iec559 = numeric_limits<T>::is_iec559;
    static constexpr bool is_integer = numeric_limits<T>::is_integer;
    static constexpr bool is_modulo = numeric_limits<T>::is_modulo;
    static constexpr bool is_signed = numeric_limits<T>::is_signed;
    static constexpr bool tinyness_before = numeric_limits<T>::tinyness_before;
    static constexpr bool traps = numeric_limits<T>::traps;
    static constexpr float_denorm_style has_denorm =
        numeric_limits<T>::has_denorm;
    static constexpr float_round_style round_style =
        numeric_limits<T>::round_style;
    static constexpr int digits = numeric_limits<T>::digits;
    static constexpr int digits10 = numeric_limits<T>::digits10;
    static constexpr int max_digits10 = numeric_limits<T>::max_digits10;
    static constexpr int max_exponent = numeric_limits<T>::max_exponent;
    static constexpr int max_exponent10 = numeric_limits<T>::max_exponent10;
    static constexpr int min_exponent = numeric_limits<T>::min_exponent;
    static constexpr int min_exponent10 = numeric_limits<T>::min_exponent10;
    static constexpr int radix = numeric_limits<T>::radix;
 
    static constexpr auto denorm_min() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::denorm_min());
    }
    static constexpr auto epsilon() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::epsilon());
    }
    static constexpr auto infinity() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::infinity());
    }
    static constexpr auto lowest() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::lowest());
    }
    static constexpr auto max() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::max());
    }
    static constexpr auto min() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::min());
    }
    static constexpr auto quiet_NaN() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::quiet_NaN());
    }
    static constexpr auto round_error() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::round_error());
    }
    static constexpr auto signaling_NaN() -> tcspc::npint<T> {
        return tcspc::npint<T>(numeric_limits<T>::signaling_NaN());
    }
};
 
} // namespace std