|
| 1 | +#pragma once |
| 2 | + |
| 3 | +#include <stdx/concepts.hpp> |
| 4 | + |
| 5 | +#include <type_traits> |
| 6 | + |
| 7 | +namespace stdx { |
| 8 | +inline namespace v1 { |
| 9 | +template <typename T> struct rollover_t { |
| 10 | + static_assert(unsigned_integral<T>, |
| 11 | + "Argument to rollover_t must be an unsigned integral type."); |
| 12 | + using underlying_t = T; |
| 13 | + |
| 14 | + constexpr rollover_t() = default; |
| 15 | + template <typename U, |
| 16 | + typename = std::enable_if_t<std::is_convertible_v<U, T>>> |
| 17 | + constexpr explicit rollover_t(U u) : value{static_cast<underlying_t>(u)} {} |
| 18 | + template <typename U, |
| 19 | + typename = std::enable_if_t<std::is_convertible_v<U, T>>> |
| 20 | + constexpr explicit rollover_t(rollover_t<U> u) |
| 21 | + : rollover_t{static_cast<U>(u)} {} |
| 22 | + |
| 23 | + [[nodiscard]] constexpr auto as_underlying() const -> underlying_t { |
| 24 | + return value; |
| 25 | + } |
| 26 | + constexpr explicit operator underlying_t() const { return value; } |
| 27 | + |
| 28 | + [[nodiscard]] constexpr auto operator+() const -> rollover_t { |
| 29 | + return *this; |
| 30 | + } |
| 31 | + [[nodiscard]] constexpr auto operator-() const -> rollover_t { |
| 32 | + return rollover_t{static_cast<underlying_t>(-value)}; |
| 33 | + } |
| 34 | + |
| 35 | + constexpr auto operator++() -> rollover_t & { |
| 36 | + ++value; |
| 37 | + return *this; |
| 38 | + } |
| 39 | + constexpr auto operator++(int) -> rollover_t { return rollover_t{value++}; } |
| 40 | + |
| 41 | + constexpr auto operator--() -> rollover_t & { |
| 42 | + --value; |
| 43 | + return *this; |
| 44 | + } |
| 45 | + constexpr auto operator--(int) -> rollover_t { return rollover_t{value--}; } |
| 46 | + |
| 47 | + constexpr auto operator+=(rollover_t other) -> rollover_t & { |
| 48 | + value += other.value; |
| 49 | + return *this; |
| 50 | + } |
| 51 | + constexpr auto operator-=(rollover_t other) -> rollover_t & { |
| 52 | + value -= other.value; |
| 53 | + return *this; |
| 54 | + } |
| 55 | + constexpr auto operator*=(rollover_t other) -> rollover_t & { |
| 56 | + value *= other.value; |
| 57 | + return *this; |
| 58 | + } |
| 59 | + constexpr auto operator/=(rollover_t other) -> rollover_t & { |
| 60 | + value /= other.value; |
| 61 | + return *this; |
| 62 | + } |
| 63 | + constexpr auto operator%=(rollover_t other) -> rollover_t & { |
| 64 | + value %= other.value; |
| 65 | + return *this; |
| 66 | + } |
| 67 | + |
| 68 | + private: |
| 69 | + [[nodiscard]] constexpr friend auto operator==(rollover_t lhs, |
| 70 | + rollover_t rhs) -> bool { |
| 71 | + return lhs.value == rhs.value; |
| 72 | + } |
| 73 | + [[nodiscard]] constexpr friend auto operator!=(rollover_t lhs, |
| 74 | + rollover_t rhs) -> bool { |
| 75 | + return not(lhs == rhs); |
| 76 | + } |
| 77 | + |
| 78 | + constexpr friend auto operator<(rollover_t, rollover_t) -> bool = delete; |
| 79 | + constexpr friend auto operator<=(rollover_t, rollover_t) -> bool = delete; |
| 80 | + constexpr friend auto operator>(rollover_t, rollover_t) -> bool = delete; |
| 81 | + constexpr friend auto operator>=(rollover_t, rollover_t) -> bool = delete; |
| 82 | + |
| 83 | + [[nodiscard]] constexpr friend auto cmp_less(rollover_t lhs, |
| 84 | + rollover_t rhs) -> bool { |
| 85 | + constexpr auto mid = static_cast<underlying_t>(~underlying_t{}) / 2; |
| 86 | + return static_cast<underlying_t>(lhs.value - rhs.value) > mid; |
| 87 | + } |
| 88 | + |
| 89 | + [[nodiscard]] constexpr friend auto |
| 90 | + operator+(rollover_t lhs, rollover_t rhs) -> rollover_t { |
| 91 | + lhs += rhs; |
| 92 | + return lhs; |
| 93 | + } |
| 94 | + [[nodiscard]] constexpr friend auto |
| 95 | + operator-(rollover_t lhs, rollover_t rhs) -> rollover_t { |
| 96 | + lhs -= rhs; |
| 97 | + return lhs; |
| 98 | + } |
| 99 | + [[nodiscard]] constexpr friend auto |
| 100 | + operator*(rollover_t lhs, rollover_t rhs) -> rollover_t { |
| 101 | + lhs *= rhs; |
| 102 | + return lhs; |
| 103 | + } |
| 104 | + [[nodiscard]] constexpr friend auto |
| 105 | + operator/(rollover_t lhs, rollover_t rhs) -> rollover_t { |
| 106 | + lhs /= rhs; |
| 107 | + return lhs; |
| 108 | + } |
| 109 | + [[nodiscard]] constexpr friend auto |
| 110 | + operator%(rollover_t lhs, rollover_t rhs) -> rollover_t { |
| 111 | + lhs %= rhs; |
| 112 | + return lhs; |
| 113 | + } |
| 114 | + |
| 115 | + underlying_t value{}; |
| 116 | +}; |
| 117 | + |
| 118 | +template <typename T> rollover_t(T) -> rollover_t<T>; |
| 119 | +} // namespace v1 |
| 120 | +} // namespace stdx |
| 121 | + |
| 122 | +template <typename T, typename U> |
| 123 | +struct std::common_type<stdx::rollover_t<T>, stdx::rollover_t<U>> { |
| 124 | + using type = stdx::rollover_t<std::common_type_t<T, U>>; |
| 125 | +}; |
| 126 | + |
| 127 | +template <typename T, typename I> |
| 128 | +struct std::common_type<stdx::rollover_t<T>, I> { |
| 129 | + using type = |
| 130 | + stdx::rollover_t<std::common_type_t<T, std::make_unsigned_t<I>>>; |
| 131 | +}; |
0 commit comments