added narrow cast

added make ready future

consistent internal namespace

bumped version to 0.4.0

Author: BestITUserEUW

include/oryx/crt/argparse.hpp

@@ -9,7 +9,7 @@
 
 namespace oryx::crt {
 
-namespace details {
+namespace detail {
 template <typename>
 constexpr bool always_false = false;
 }
@@ -40,7 +40,7 @@ class ArgumentParser {
         } else if constexpr (std::is_floating_point_v<T>) {
             return FromChars<T>(*vit);
         } else {
-            static_assert(details::always_false<T>,
+            static_assert(detail::always_false<T>,
                           "Get argument only supports std::string integral and floating point types");
         }
     }

include/oryx/crt/cycle_timer.hpp

@@ -32,7 +32,7 @@ class CycleTimer {
 
 private:
     const Duration target_;
-    details::StopwatchImpl<Clock> sw_{};
+    detail::StopwatchImpl<Clock> sw_{};
 };
 
 template <class Clock>

include/oryx/crt/make_ready_future.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <future>
+
+namespace oryx::crt {
+
+template <typename T>
+[[nodiscard]] auto MakeReadyFuture(T&& value) {
+    std::promise<std::decay_t<T>> p;
+    p.set_value(std::forward<T>(value));
+    return p.get_future();
+}
+
+[[nodiscard]] inline auto MakeReadyFuture() {
+    std::promise<void> p;
+    p.set_value();
+    return p.get_future();
+}
+
+}  // namespace oryx::crt

include/oryx/crt/narrow_cast.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+namespace oryx::crt {
+
+/**
+ * @brief Searchable way to do narrowing casts of values
+ */
+template <class T, class U>
+constexpr auto NarrowCast(U&& u) -> T {
+    return static_cast<T>(std::forward<U>(u));
+}
+
+/**
+ * @brief Checked version of NarrowCast() that returns nullopt if the cast changed the value
+ */
+template <class T, class U>
+constexpr auto Narrow(U u) -> std::optional<T>
+    requires std::is_arithmetic_v<T>
+{
+    constexpr const bool is_different_signedness = (std::is_signed_v<T> != std::is_signed_v<U>);
+
+    const T t = NarrowCast<T>(u);
+
+#if defined(__clang__) || defined(__GNUC__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    // Note: NaN will always return nullopt, since NaN != NaN
+    if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{})))) {
+        return std::nullopt;
+    }
+#if defined(__clang__) || defined(__GNUC__)
+    #pragma GCC diagnostic pop
+#endif
+
+    return t;
+}
+
+template <class T, class U>
+constexpr auto Narrow(U u) -> std::optional<T>
+    requires(!std::is_arithmetic_v<T>)
+{
+    const T t = NarrowCast<T>(u);
+    if (static_cast<U>(t) != u) {
+        return std::nullopt;
+    }
+
+    return t;
+}
+
+}  // namespace oryx::crt

include/oryx/crt/stopwatch.hpp

@@ -3,7 +3,7 @@
 #include <chrono>
 
 namespace oryx::crt {
-namespace details {
+namespace detail {
 
 template <class Clock>
     requires std::chrono::is_clock_v<Clock>
@@ -27,9 +27,9 @@ class StopwatchImpl {
     Clock::time_point start_;
 };
 
-}  // namespace details
+}  // namespace detail
 
-using HighResolutionStopwatch = details::StopwatchImpl<std::chrono::high_resolution_clock>;
-using Stopwatch = details::StopwatchImpl<std::chrono::steady_clock>;
+using HighResolutionStopwatch = detail::StopwatchImpl<std::chrono::high_resolution_clock>;
+using Stopwatch = detail::StopwatchImpl<std::chrono::steady_clock>;
 
 }  // namespace oryx::crt

include/oryx/crt/version.hpp

@@ -5,7 +5,7 @@
 namespace oryx::crt {
 
 inline constexpr int kVersionMajor = 0;
-inline constexpr int KVersionMinor = 3;
+inline constexpr int KVersionMinor = 4;
 inline constexpr int kVersionPatch = 0;
 
 auto MakeStringVersion() -> std::string;

tests/make_ready_future.cpp

@@ -0,0 +1,21 @@
+#include "doctest.hpp"
+
+#include <oryx/crt/make_ready_future.hpp>
+
+using namespace oryx::crt;
+
+TEST_CASE("future should not throw when calling get()") {
+    auto fut = MakeReadyFuture(42);
+    CHECK_NOTHROW(fut.get());
+}
+
+TEST_CASE("void future should not throw when calling get()") {
+    auto fut = MakeReadyFuture();
+    CHECK_NOTHROW(fut.get());
+}
+
+TEST_CASE("get() should return what was passed") {
+    auto fut = MakeReadyFuture(42);
+    CHECK(fut.valid());
+    CHECK(fut.get() == 42);
+}

tests/narrow_cast.cpp

@@ -0,0 +1,49 @@
+#include "doctest.hpp"
+
+#include <cstdint>
+#include <limits>
+
+#include <oryx/crt/narrow_cast.hpp>
+
+using namespace oryx::crt;
+
+TEST_CASE("same type conversions") {
+    CHECK(Narrow<int, int>(0) == 0);
+    CHECK(Narrow<int, int>(42) == 42);
+    CHECK(Narrow<unsigned, unsigned>(123u) == 123u);
+}
+
+TEST_CASE("signed to signed") {
+    CHECK(Narrow<int8_t, int>(127) == 127);
+    CHECK(Narrow<int8_t, int>(-128) == -128);
+
+    CHECK_FALSE(Narrow<int8_t, int>(128).has_value());
+    CHECK_FALSE(Narrow<int8_t, int>(-129).has_value());
+}
+
+TEST_CASE("unsigned to unsigned") {
+    CHECK(Narrow<uint8_t, unsigned>(255u) == 255u);
+    CHECK_FALSE(Narrow<uint8_t, unsigned>(256u).has_value());
+}
+
+TEST_CASE("signed to unsigned") {
+    CHECK(Narrow<unsigned, int>(0) == 0u);
+    CHECK(Narrow<unsigned, int>(42) == 42u);
+
+    CHECK_FALSE(Narrow<unsigned, int>(-1).has_value());
+    CHECK_FALSE(Narrow<uint8_t, int>(std::numeric_limits<int>::max()).has_value());
+}
+
+TEST_CASE("unsigned to signed") {
+    CHECK(Narrow<int, unsigned>(0u) == 0);
+    CHECK(Narrow<int, unsigned>(42u) == 42);
+
+    CHECK_FALSE(Narrow<int8_t, unsigned>(128u).has_value());
+}
+
+TEST_CASE("boundary conditions") {
+    CHECK(Narrow<int, unsigned>(static_cast<unsigned>(std::numeric_limits<int>::max())) ==
+          std::numeric_limits<int>::max());
+
+    CHECK_FALSE(Narrow<int, unsigned>(static_cast<unsigned>(std::numeric_limits<int>::max()) + 1u).has_value());
+}

tests/stopwatch_test.cpp

@@ -9,15 +9,15 @@
 using namespace oryx::crt;
 
 TEST_CASE("Reset calls clock now") {
-    details::StopwatchImpl<oryx::crt::ChronoMockClock> sw{};
+    detail::StopwatchImpl<oryx::crt::ChronoMockClock> sw{};
     const auto tp = oryx::crt::ChronoMockClock::time_point{std::chrono::seconds(5)};
     oryx::crt::ChronoMockClock::set_time(tp);
     sw.Reset();
     CHECK_EQ(sw.GetStart(), tp);
 }
 
 TEST_CASE("Elapsed and elapsed ms subtracts now from start") {
-    details::StopwatchImpl<oryx::crt::ChronoMockClock> sw{
+    detail::StopwatchImpl<oryx::crt::ChronoMockClock> sw{
         oryx::crt::ChronoMockClock::time_point{std::chrono::seconds(5)}};
     const auto tp = oryx::crt::ChronoMockClock::time_point{std::chrono::seconds(10)};
     oryx::crt::ChronoMockClock::set_time(tp);