Merge pull request #74 from saxbophone/josh/47-other-cast-operators

47 other cast operators

Author: saxbophone

arby/include/arby/Nat.hpp

@@ -257,11 +257,43 @@ namespace com::saxbophone::arby {
             return this->_cast_to<uintmax_t>();
         }
         /**
-         * @returns Value of this Nat object cast to long long double
+         * @returns Value of this Nat object cast to long double
          */
         explicit constexpr operator long double() const {
             return this->_cast_to<long double>();
         }
+        /**
+         * @returns Value of this Nat object cast to float
+         */
+        explicit constexpr operator float() const {
+            return this->_cast_to<float>();
+        }
+        /**
+         * @returns Value of this Nat object cast to double
+         */
+        explicit constexpr operator double() const {
+            return this->_cast_to<double>();
+        }
+        /**
+         * @returns Value of this Nat object cast to any numeric type
+         * @tparam To The data type to cast to
+         */
+        template <typename To>
+        explicit constexpr operator To() const {
+            // prevent overflow of To if it's a bounded type
+            if constexpr (std::numeric_limits<To>::is_bounded) {
+                if (*this > std::numeric_limits<To>::max()) {
+                    throw std::range_error("value too large for destination type");
+                }
+            }
+            // take a short-cut if destination type is bounded and is not bigger than largest digit value
+            if constexpr (std::numeric_limits<To>::is_bounded and std::numeric_limits<To>::max() <= (BASE - 1)) {
+                // at this point, out-of-bounds has already been checked. Just return last digit
+                return _digits.empty() ? (To)0 : (To)_digits.back();
+            } else {
+                return this->_cast_to<To>();
+            }
+        }
         /**
          * @brief custom ostream operator that allows class Nat to be printed
          * with std::cout and friends

tests/Nat/casting.cpp

@@ -21,10 +21,41 @@ TEST_CASE("Casting arby::Nat with value higher than UINT_MAX to uintmax_t throws
     CHECK_THROWS_AS((uintmax_t)value, std::range_error);
 }
 
-TEST_CASE("Casting arby::Nat to long double", "[casting]") {
+TEMPLATE_TEST_CASE("Casting arby::Nat to various floating-point types", "[casting]", float, double, long double) {
     auto value = GENERATE(take(1000, random((uintmax_t)0, std::numeric_limits<uintmax_t>::max())));
 
-    CHECK((long double)arby::Nat(value) == (long double)value);
+    // float is so imprecise for large values that we need to cast the input too
+    CHECK((TestType)arby::Nat::from_float((TestType)value) == (TestType)value);
+}
+
+TEMPLATE_TEST_CASE(
+    "Casting arby::Nat with value higher than max to other type throws range_error", "[casting]",
+    std::uint8_t, std::int8_t, std::uint16_t, std::int16_t, std::uint32_t, std::int32_t
+) {
+    arby::Nat value = arby::Nat((uintmax_t)std::numeric_limits<TestType>::max()) + 1;
+
+    CHECK_THROWS_AS((TestType)value, std::range_error);
+}
+
+TEST_CASE("Casting arby::Nat to other type - uint8_t", "[casting]",) {
+    auto value = GENERATE(take(1000, random((std::uint16_t)0, (std::uint16_t)std::numeric_limits<std::uint8_t>::max())));
+
+    CHECK((std::uint8_t)arby::Nat((uintmax_t)value) == (std::uint8_t)value);
+}
+
+TEST_CASE("Casting arby::Nat to other type - int8_t", "[casting]",) {
+    auto value = GENERATE(take(1000, random((std::int16_t)0, (std::int16_t)std::numeric_limits<std::int8_t>::max())));
+
+    CHECK((std::int8_t)arby::Nat((uintmax_t)value) == (std::int8_t)value);
+}
+
+TEMPLATE_TEST_CASE(
+    "Casting arby::Nat to other type", "[casting]",
+    std::uint16_t, std::int16_t, std::uint32_t, std::int32_t
+) {
+    auto value = GENERATE(take(1000, random((TestType)0, std::numeric_limits<TestType>::max())));
+
+    CHECK((TestType)arby::Nat((uintmax_t)value) == (TestType)value);
 }
 
 TEST_CASE("arby::Nat::from_float() with negative value throws std::domain_error") {