fixed std::to_underlying not being available in c++20

Author: BestITUserEUW

CMakeLists.txt

@@ -75,6 +75,12 @@ target_sources(${PROJECT_NAME}
         FILES ${ORYX_CHRON_HEADERS}
 )
 
+# Experimental
+target_precompile_headers(${PROJECT_NAME} PUBLIC
+    <string>
+    <chrono>
+)
+
 if(ORYX_CHRON_SANITIZE_ADDRESS)
     oryx_enable_addr_sanitizer(${PROJECT_NAME})
 elseif(ORYX_CHRON_SANITIZE_THREAD)

include/oryx/chron/data.hpp

@@ -2,19 +2,21 @@
 
 #include <cstdint>
 #include <string>
+#include <string_view>
 #include <set>
 #include <regex>
 #include <string>
-#include <utility>
 #include <vector>
 #include <array>
 #include <span>
-#include <utility>
+#include <type_traits>
+#include <iterator>
 
 #include <oryx/chron/time_types.hpp>
 #include <oryx/chron/details/string_split.hpp>
 #include <oryx/chron/details/ctre.hpp>
 #include <oryx/chron/details/string_cast.hpp>
+#include <oryx/chron/details/to_underlying.hpp>
 
 namespace oryx::chron {
 
@@ -101,7 +103,7 @@ template <typename T>
 auto Data::ValidateLiteral(const std::string& s, std::set<T>& numbers, std::span<const std::string_view> names)
     -> bool {
     auto parts = details::StringSplit(s, ',');
-    auto value_of_first_name = std::to_underlying(T::First);
+    auto value_of_first_name = details::to_underlying(T::First);
 
     for (auto& name : names) {
         std::regex regex_pattern(name.data(), std::regex_constants::ECMAScript | std::regex_constants::icase);
@@ -145,7 +147,7 @@ template <typename T>
 auto Data::GetStep(std::string_view s, uint8_t& start, uint8_t& step) -> bool {
     if (auto match = ctre::match<R"#((\d+|\*)/(\d+))#">(s)) {
         auto first = match.get<1>().to_view();
-        int raw_start = (first == "*") ? std::to_underlying(T::First) : details::StringCast<int>(first);
+        int raw_start = (first == "*") ? details::to_underlying(T::First) : details::StringCast<int>(first);
         int raw_step = details::StringCast<int>(match.get<2>().to_view());
         if (IsWithinLimits<T>(raw_start, raw_start) && raw_step > 0) {
             start = static_cast<uint8_t>(raw_start);
@@ -158,7 +160,7 @@ auto Data::GetStep(std::string_view s, uint8_t& start, uint8_t& step) -> bool {
 
 template <typename T>
 auto Data::AddFullRange(std::set<T>& set) -> void {
-    for (auto v = std::to_underlying(T::First); v <= std::to_underlying(T::Last); ++v) {
+    for (auto v = details::to_underlying(T::First); v <= details::to_underlying(T::Last); ++v) {
         if (set.find(static_cast<T>(v)) == set.end()) {
             set.emplace(static_cast<T>(v));
         }
@@ -175,8 +177,8 @@ auto Data::AddNumber(std::set<T>& set, int32_t number) -> bool {
 
 template <typename T>
 auto Data::IsWithinLimits(int32_t low, int32_t high) -> bool {
-    return IsBetween(low, std::to_underlying(T::First), std::to_underlying(T::Last)) &&
-           IsBetween(high, std::to_underlying(T::First), std::to_underlying(T::Last));
+    return IsBetween(low, details::to_underlying(T::First), details::to_underlying(T::Last)) &&
+           IsBetween(high, details::to_underlying(T::First), details::to_underlying(T::Last));
 }
 
 template <typename T>
@@ -191,19 +193,19 @@ auto Data::ConvertFromStringRangeToNumberRange(std::string_view range, std::set<
         result = AddNumber<T>(numbers, details::StringCast<int32_t>(range));
     } else if (GetRange<T>(range, left, right)) {
         if (left <= right) {
-            for (auto v = std::to_underlying(left); v <= std::to_underlying(right); ++v) {
+            for (auto v = details::to_underlying(left); v <= details::to_underlying(right); ++v) {
                 result &= AddNumber(numbers, v);
             }
         } else {
-            for (auto v = std::to_underlying(left); v <= std::to_underlying(T::Last); ++v) {
+            for (auto v = details::to_underlying(left); v <= details::to_underlying(T::Last); ++v) {
                 result &= AddNumber(numbers, v);
             }
-            for (auto v = std::to_underlying(T::First); v <= std::to_underlying(right); ++v) {
+            for (auto v = details::to_underlying(T::First); v <= details::to_underlying(right); ++v) {
                 result &= AddNumber(numbers, v);
             }
         }
     } else if (GetStep<T>(range, step_start, step)) {
-        for (auto v = step_start; v <= std::to_underlying(T::Last); v += step) {
+        for (auto v = step_start; v <= details::to_underlying(T::Last); v += step) {
             result &= AddNumber(numbers, v);
         }
     } else {
@@ -216,7 +218,7 @@ auto Data::ConvertFromStringRangeToNumberRange(std::string_view range, std::set<
 template <typename T>
     requires(std::is_same_v<T, Months> || std::is_same_v<T, DayOfWeek>)
 auto Data::ReplaceStringNameWithNumeric(std::string& s) -> std::string& {
-    auto value = std::to_underlying(T::First);
+    auto value = details::to_underlying(T::First);
 
     if constexpr (std::is_same_v<T, Months>) {
         for (auto name : kMonthNames) {

include/oryx/chron/details/any_of.hpp

@@ -2,7 +2,8 @@
 
 #include <cstdint>
 #include <set>
-#include <utility>
+
+#include <oryx/chron/details/to_underlying.hpp>
 
 namespace oryx::chron::details {
 
@@ -23,7 +24,7 @@ auto AnyOf(const std::set<T>& set, uint8_t low, uint8_t high) -> bool {
 template <typename Enum>
     requires std::is_enum_v<Enum>
 auto AnyOf(const std::set<Enum>& set, Enum low, Enum high) -> bool {
-    for (auto i = std::to_underlying(low); i <= std::to_underlying(high); ++i)
+    for (auto i = details::to_underlying(low); i <= details::to_underlying(high); ++i)
         if (set.contains(static_cast<Enum>(i))) return true;
     return false;
 }

include/oryx/chron/details/to_underlying.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <utility>
+#include <type_traits>
+
+namespace oryx::chron::details {
+
+#ifndef __cpp_lib_to_underlying
+
+template <typename Enum>
+    requires std::is_enum_v<Enum>
+constexpr auto to_underlying(Enum e) noexcept -> std::underlying_type_t<Enum> {
+    return static_cast<std::underlying_type_t<Enum>>(e);
+}
+
+#else
+
+using std::to_underlying;
+
+#endif
+
+}  // namespace oryx::chron::details

include/oryx/chron/schedule.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <tuple>
+
 #include <oryx/chron/data.hpp>
 #include <oryx/chron/date_time.hpp>
 #include <oryx/chron/chrono_types.hpp>

src/randomization.cpp

@@ -11,6 +11,7 @@
 #include <oryx/chron/data.hpp>
 #include <oryx/chron/details/ctre.hpp>
 #include <oryx/chron/details/string_cast.hpp>
+#include <oryx/chron/details/to_underlying.hpp>
 
 namespace oryx::chron {
 namespace {
@@ -41,7 +42,7 @@ auto GetRandomInRange(std::string_view section,
         // Remove items outside the limit
         if (limit.first != -1 && limit.second != -1) {
             for (auto it = numbers.begin(); it != numbers.end();) {
-                if (std::to_underlying(*it) < limit.first || std::to_underlying(*it) > limit.second) {
+                if (details::to_underlying(*it) < limit.first || details::to_underlying(*it) > limit.second) {
                     it = numbers.erase(it);
                 } else {
                     ++it;
@@ -54,7 +55,7 @@ auto GetRandomInRange(std::string_view section,
             std::uniform_int_distribution<> distribution(0, static_cast<int>(numbers.size() - 1));
             auto it = numbers.begin();
             std::advance(it, distribution(twister));
-            selected_value = std::to_underlying(*it);
+            selected_value = details::to_underlying(*it);
             result.second = std::to_string(selected_value);
         }
     } else {
@@ -66,7 +67,7 @@ auto GetRandomInRange(std::string_view section,
 }
 
 auto DayLimiter(const std::set<Months>& months) -> std::pair<int, int> {
-    int max = std::to_underlying(DayOfMonth::Last);
+    int max = details::to_underlying(DayOfMonth::Last);
 
     for (auto month : months) {
         if (month == Months::February) {
@@ -78,7 +79,7 @@ auto DayLimiter(const std::set<Months>& months) -> std::pair<int, int> {
         }
     }
 
-    return {std::to_underlying(DayOfMonth::First), max};
+    return {details::to_underlying(DayOfMonth::First), max};
 }
 
 }  // namespace

src/schedule.cpp

@@ -2,6 +2,8 @@
 
 #include <tuple>
 
+#include <oryx/chron/details/to_underlying.hpp>
+
 using namespace std::chrono;
 
 namespace oryx::chron {
@@ -24,7 +26,7 @@ auto Schedule::CalculateFrom(const TimePoint& from) const -> std::tuple<bool, Ti
             date_changed = true;
         }
         // If all days are allowed (or the field is ignored via '?'), then the 'day of week' takes precedence.
-        else if (data_.GetDayOfMonth().size() != std::to_underlying(DayOfMonth::Last)) {
+        else if (data_.GetDayOfMonth().size() != details::to_underlying(DayOfMonth::Last)) {
             // Add days until one of the allowed days are found, or stay at the current one.
             if (data_.GetDayOfMonth().find(static_cast<DayOfMonth>(unsigned(ymd.day()))) ==
                 data_.GetDayOfMonth().end()) {