From 3c86aae616647d0b38ea4e808e15c33b5b62853f Mon Sep 17 00:00:00 2001
From: Gary Talent <gtalent2@gmail.com>
Date: Sat, 27 Jul 2019 23:56:49 -0500
Subject: [PATCH] [ox/std] Fix several problems that arose when trying to use
 strong ints

---
 deps/ox/src/ox/std/strongint.hpp | 84 +++++++++++++++++++++-----------
 1 file changed, 56 insertions(+), 28 deletions(-)

diff --git a/deps/ox/src/ox/std/strongint.hpp b/deps/ox/src/ox/std/strongint.hpp
index 23eb40e3..03316ce4 100644
--- a/deps/ox/src/ox/std/strongint.hpp
+++ b/deps/ox/src/ox/std/strongint.hpp
@@ -6,6 +6,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
+#pragma once
+
 #include "types.hpp"
 
 namespace ox {
@@ -58,13 +60,13 @@ class Integer {
 
 		constexpr Integer<T> operator%=(Integer<T> i) noexcept;
 
-		constexpr Integer<T> operator>>(Integer<T> i) const noexcept;
+		constexpr Integer<T> operator>>(int i) const noexcept;
 
-		constexpr Integer<T> operator>>=(Integer<T> i) noexcept;
+		constexpr Integer<T> operator>>=(int i) noexcept;
 
-		constexpr Integer<T> operator<<(Integer<T> i) const noexcept;
+		constexpr Integer<T> operator<<(int i) const noexcept;
 
-		constexpr Integer<T> operator<<=(Integer<T> i) noexcept;
+		constexpr Integer<T> operator<<=(int i) noexcept;
 
 		constexpr Integer<T> operator|(Integer<T> i) const noexcept;
 
@@ -90,9 +92,10 @@ class Integer {
 		// Postfix decrement
 		constexpr Integer<T> operator--(int) noexcept;
 
-		// Postfix decrement
 		constexpr explicit operator T() const noexcept;
 
+		constexpr operator bool() const noexcept;
+
 };
 
 template<typename T>
@@ -102,117 +105,137 @@ constexpr Integer<T>::Integer(T i) noexcept {
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator=(Integer<T> i) noexcept {
-	return m_i = i.m_i;
+	return Integer<T>(m_i = i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator==(Integer<T> i) const noexcept {
-	return m_i == i.m_i;
+	return Integer<T>(m_i == i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator!=(Integer<T> i) const noexcept {
-	return m_i != i.m_i;
+	return Integer<T>(m_i != i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator<(Integer<T> i) const noexcept {
-	return m_i < i.m_i;
+	return Integer<T>(m_i < i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator>(Integer<T> i) const noexcept {
-	return m_i > i.m_i;
+	return Integer<T>(m_i > i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator<=(Integer<T> i) const noexcept {
-	return m_i <= i.m_i;
+	return Integer<T>(m_i <= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator>=(Integer<T> i) const noexcept {
-	return m_i >= i.m_i;
+	return Integer<T>(m_i >= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator+(Integer<T> i) const noexcept {
-	return m_i + i.m_i;
+	return Integer<T>(m_i + i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator+=(Integer<T> i) noexcept {
-	return m_i += i.m_i;
+	return Integer<T>(m_i += i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator-(Integer<T> i) const noexcept {
-	return m_i - i.m_i;
+	return Integer<T>(m_i - i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator-=(Integer<T> i) noexcept {
-	return m_i -= i.m_i;
+	return Integer<T>(m_i -= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator*(Integer<T> i) const noexcept {
-	return m_i * i.m_i;
+	return Integer<T>(m_i * i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator*=(Integer<T> i) noexcept {
-	return m_i *= i.m_i;
+	return Integer<T>(m_i *= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator/(Integer<T> i) const noexcept {
-	return m_i / i.m_i;
+	return Integer<T>(m_i / i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator/=(Integer<T> i) noexcept {
-	return m_i /= i.m_i;
+	return Integer<T>(m_i /= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator%(Integer<T> i) const noexcept {
-	return m_i % i.m_i;
+	return Integer<T>(m_i % i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator%=(Integer<T> i) noexcept {
-	return m_i %= i.m_i;
+	return Integer<T>(m_i %= i.m_i);
+}
+
+template<typename T>
+constexpr Integer<T> Integer<T>::operator>>(int i) const noexcept {
+	return Integer<T>(m_i >> i);
+}
+
+template<typename T>
+constexpr Integer<T> Integer<T>::operator>>=(int i) noexcept {
+	return Integer<T>(m_i >>= i);
+}
+
+template<typename T>
+constexpr Integer<T> Integer<T>::operator<<(int i) const noexcept {
+	return Integer<T>(m_i << i);
+}
+
+template<typename T>
+constexpr Integer<T> Integer<T>::operator<<=(int i) noexcept {
+	return Integer<T>(m_i <<= i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator|(Integer<T> i) const noexcept {
-	return m_i | i.m_i;
+	return Integer<T>(m_i | i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator|=(Integer<T> i) noexcept {
-	return m_i |= i.m_i;
+	return Integer<T>(m_i |= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator&(Integer<T> i) const noexcept {
-	return m_i & i.m_i;
+	return Integer<T>(m_i & i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator&=(Integer<T> i) noexcept {
-	return m_i &= i.m_i;
+	return Integer<T>(m_i &= i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator^(Integer<T> i) const noexcept {
-	return m_i ^ i.m_i;
+	return Integer<T>(m_i ^ i.m_i);
 }
 
 template<typename T>
 constexpr Integer<T> Integer<T>::operator^=(Integer<T> i) noexcept {
-	return m_i ^= i.m_i;
+	return Integer<T>(m_i ^= i.m_i);
 }
 
 // Prefix increment
@@ -244,6 +267,11 @@ constexpr Integer<T>::operator T() const noexcept {
 	return m_i;
 }
 
+template<typename T>
+constexpr Integer<T>::operator bool() const noexcept {
+	return m_i;
+}
+
 using Int8  = Integer<int8_t>;
 using Int16 = Integer<int16_t>;
 using Int32 = Integer<int32_t>;