refactored last usage of std::regex_replace

use std::optional<T> instead of std::tuple<bool , T>

removed unused regex

Author: BestITUserEUW

include/oryx/chron/data.hpp

@@ -4,19 +4,18 @@
 #include <string>
 #include <string_view>
 #include <set>
-#include <regex>
 #include <string>
 #include <vector>
 #include <array>
 #include <span>
 #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>
+#include <oryx/chron/details/time_types_transform.hpp>
 
 namespace oryx::chron {
 
@@ -28,11 +27,6 @@ class Data {
     static constexpr std::array<Months, kNumberOfLongMonths> kMonthsWith31{
         Months::January, Months::March, Months::May, Months::July, Months::August, Months::October, Months::December};
 
-    static constexpr std::array<std::string_view, 12> kMonthNames{"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
-                                                                  "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
-
-    static constexpr std::array<std::string_view, 7> kDayNames{"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
-
     Data() = default;
 
     auto IsValid() const -> bool { return valid_; }
@@ -103,26 +97,15 @@ 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 = details::to_underlying(T::First);
-
-    for (auto& name : names) {
-        std::regex regex_pattern(name.data(), std::regex_constants::ECMAScript | std::regex_constants::icase);
-
-        for (auto& part : parts) {
-            std::string replaced;
-            std::regex_replace(std::back_inserter(replaced), part.begin(), part.end(), regex_pattern,
-                               std::to_string(value_of_first_name));
-            part = replaced;
-        }
-        ++value_of_first_name;
+    for (auto& part : parts) {
+        details::ReplaceWithNumeric<T>(part, names);
     }
-
     return ProcessParts(parts, numbers);
 }
 
 template <typename T>
 auto Data::ProcessParts(const std::vector<std::string>& parts, std::set<T>& numbers) -> bool {
-    bool result = true;
+    bool result{true};
     for (auto& part : parts) {
         result &= ConvertFromStringRangeToNumberRange(part, numbers);
     }
@@ -215,28 +198,4 @@ auto Data::ConvertFromStringRangeToNumberRange(std::string_view range, std::set<
     return result;
 }
 
-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 = details::to_underlying(T::First);
-
-    if constexpr (std::is_same_v<T, Months>) {
-        for (auto name : kMonthNames) {
-            std::regex regex_pattern(name.data(), std::regex_constants::ECMAScript | std::regex_constants::icase);
-            std::string replaced;
-            std::regex_replace(std::back_inserter(replaced), s.begin(), s.end(), regex_pattern, std::to_string(value));
-            s = replaced;
-            ++value;
-        }
-    } else {
-        for (auto name : kDayNames) {
-            std::regex regex_pattern(name.data(), std::regex_constants::ECMAScript | std::regex_constants::icase);
-            std::string replaced;
-            std::regex_replace(std::back_inserter(replaced), s.begin(), s.end(), regex_pattern, std::to_string(value));
-            s = replaced;
-            ++value;
-        }
-    }
-    return s;
-}
 }  // namespace oryx::chron

include/oryx/chron/details/time_types_transform.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <array>
+#include <span>
+#include <algorithm>
+
+#include "oryx/chron/time_types.hpp"
+#include "to_underlying.hpp"
+
+namespace oryx::chron::details {
+
+inline constexpr std::array<std::string_view, 12> kMonthNames{"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
+                                                              "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
+
+inline constexpr std::array<std::string_view, 7> kDayNames{"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
+
+using NamesView = std::span<const std::string_view>;
+
+template <typename T>
+auto ReplaceWithNumeric(std::string& data, NamesView names) -> std::string& {
+    static auto find_icase = [](std::string_view haystack, std::string_view needle) {
+        return std::ranges::search(
+            haystack, needle, [](const int lhs, const int rhs) { return lhs == rhs; },
+            [](const int lhs) { return std::toupper(lhs); });
+    };
+
+    auto value = to_underlying(T::First);
+
+    std::string cached_str_value;
+    for (auto& name : names) {
+        std::string_view view{data};
+        size_t search_start = 0;
+
+        while (search_start < view.size()) {
+            auto subview = view.substr(search_start);
+            auto found = find_icase(subview, name);
+
+            if (found.empty()) {
+                break;
+            }
+
+            if (cached_str_value.empty()) {
+                cached_str_value = std::to_string(value);
+            }
+
+            auto found_pos = search_start + std::distance(subview.begin(), found.begin());
+            data.replace(found_pos, name.size(), cached_str_value);
+
+            // Update part_view to reflect the changes and move search position
+            view = data;
+            search_start = found_pos + cached_str_value.size();
+        }
+        cached_str_value.clear();
+        value++;
+    }
+    return data;
+}
+
+inline auto ReplaceDayNameWithNumeric(std::string& data) -> std::string& {
+    return ReplaceWithNumeric<DayOfWeek>(data, kDayNames);
+}
+
+inline auto ReplaceMonthNameWithNumeric(std::string& data) -> std::string& {
+    return ReplaceWithNumeric<Months>(data, kMonthNames);
+}
+
+}  // namespace oryx::chron::details

include/oryx/chron/randomization.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <string_view>
-#include <tuple>
+#include <optional>
 #include <random>
 
 namespace oryx::chron {
@@ -12,7 +12,7 @@ class Randomization {
     Randomization(const Randomization&) = delete;
     auto operator=(const Randomization&) -> Randomization& = delete;
 
-    auto Parse(std::string_view cron_schedule) -> std::tuple<bool, std::string>;
+    auto Parse(std::string_view cron_schedule) -> std::optional<std::string>;
 
 private:
     std::random_device random_device_;

include/oryx/chron/schedule.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <tuple>
+#include <optional>
 
 #include <oryx/chron/data.hpp>
 #include <oryx/chron/date_time.hpp>
@@ -12,7 +12,7 @@ class Schedule {
     explicit Schedule(Data data)
         : data_(std::move(data)) {}
 
-    auto CalculateFrom(const TimePoint& from) const -> std::tuple<bool, TimePoint>;
+    auto CalculateFrom(const TimePoint& from) const -> std::optional<TimePoint>;
 
     static auto ToCalendarTime(TimePoint time) -> DateTime;
 

include/oryx/chron/traits.hpp

@@ -9,10 +9,7 @@ namespace oryx::chron::traits {
 
 template <typename T>
 concept Clock = requires(const T& t, TimePoint tp) {
-    // Must provide: Now() -> std::chrono::system_clock::time_point
     { t.Now() } -> std::same_as<TimePoint>;
-
-    // Must provide: UtcOffset(time_point) -> std::chrono::seconds
     { t.UtcOffset(tp) } -> std::same_as<std::chrono::seconds>;
 };
 

src/data.cpp

@@ -60,8 +60,6 @@ auto Data::Create<DataCachePolicy::kBypassCache>(const std::string& cron_express
 }
 
 void Data::Parse(std::string_view cron_expression) {
-    static const std::regex kSplit{R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#",
-                                   std::regex_constants::ECMAScript};
     static constexpr std::array<DollarExprPair, 6> kShortcuts{
         DollarExprPair("@yearly", "0 0 0 1 1 *"),  DollarExprPair("@annually", "0 0 0 1 1 *"),
         DollarExprPair("@monthly", "0 0 0 1 * *"), DollarExprPair("@weekly", "0 0 0 * * 0"),
@@ -79,8 +77,8 @@ void Data::Parse(std::string_view cron_expression) {
         valid_ &= ValidateNumeric<Minutes>(match.get<2>().to_view(), minutes_);
         valid_ &= ValidateNumeric<Hours>(match.get<3>().to_view(), hours_);
         valid_ &= ValidateNumeric<DayOfMonth>(match.get<4>().to_view(), day_of_month_);
-        valid_ &= ValidateLiteral<Months>(match.get<5>().to_string(), months_, kMonthNames);
-        valid_ &= ValidateLiteral<DayOfWeek>(match.get<6>().to_string(), day_of_week_, kDayNames);
+        valid_ &= ValidateLiteral<Months>(match.get<5>().to_string(), months_, details::kMonthNames);
+        valid_ &= ValidateLiteral<DayOfWeek>(match.get<6>().to_string(), day_of_week_, details::kDayNames);
         valid_ &= CheckDomVsDow(match.get<4>().to_view(), match.get<6>().to_view());
         valid_ &= ValidateDateVsMonths();
     }

src/randomization.cpp

@@ -1,7 +1,7 @@
+#include <optional>
 #include <oryx/chron/randomization.hpp>
 
 #include <algorithm>
-#include <regex>
 #include <map>
 #include <array>
 #include <iterator>
@@ -87,7 +87,7 @@ auto DayLimiter(const std::set<Months>& months) -> std::pair<int, int> {
 Randomization::Randomization()
     : twister_(random_device_()) {}
 
-auto Randomization::Parse(std::string_view cron_schedule) -> std::tuple<bool, std::string> {
+auto Randomization::Parse(std::string_view cron_schedule) -> std::optional<std::string> {
     // Split on space to get each separate part, six parts expected
     auto matcher = ctre::match<R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#">;
     // Replace text with numbers
@@ -96,10 +96,10 @@ auto Randomization::Parse(std::string_view cron_schedule) -> std::tuple<bool, st
     if (auto match = matcher(cron_schedule)) {
         // Replace month and day names first
         auto month = match.get<5>().to_string();
-        Data::ReplaceStringNameWithNumeric<Months>(month);
+        details::ReplaceMonthNameWithNumeric(month);
 
         auto dow = match.get<6>().to_string();
-        Data::ReplaceStringNameWithNumeric<DayOfWeek>(dow);
+        details::ReplaceDayNameWithNumeric(dow);
 
         // Merge all sections into one string
         working_copy = std::format("{} {} {} {} {} {}", match.get<1>().to_view(), match.get<2>().to_view(),
@@ -146,8 +146,10 @@ auto Randomization::Parse(std::string_view cron_schedule) -> std::tuple<bool, st
         success &= day_of_week.first;
         final_cron_schedule += " " + day_of_week.second;
     }
-
-    return {success, final_cron_schedule};
+    if (success) {
+        return final_cron_schedule;
+    }
+    return std::nullopt;
 }
 
 }  // namespace oryx::chron

src/schedule.cpp

@@ -1,17 +1,17 @@
-#include <oryx/chron/schedule.hpp>
-
-#include <tuple>
+#include <optional>
 
+#include <oryx/chron/schedule.hpp>
 #include <oryx/chron/details/to_underlying.hpp>
+#include <oryx/chron/chrono_types.hpp>
 
 using namespace std::chrono;
 
 namespace oryx::chron {
 
-auto Schedule::CalculateFrom(const TimePoint& from) const -> std::tuple<bool, TimePoint> {
+auto Schedule::CalculateFrom(const TimePoint& from) const -> std::optional<TimePoint> {
     auto curr = from;
 
-    bool done = false;
+    bool done{};
     auto max_iterations = std::numeric_limits<uint16_t>::max();
 
     while (!done && --max_iterations > 0) {
@@ -74,14 +74,16 @@ auto Schedule::CalculateFrom(const TimePoint& from) const -> std::tuple<bool, Ti
     //  the `tick()` within the same second will never be earlier than schedule time,
     //  and the task will trigger in that `tick()`.
     curr -= curr.time_since_epoch() % seconds{1};
-
-    return std::make_tuple(max_iterations > 0, curr);
+    if (max_iterations > 0) {
+        return curr;
+    }
+    return std::nullopt;
 }
 
 auto Schedule::ToCalendarTime(TimePoint time) -> DateTime {
-    auto daypoint = std::chrono::floor<std::chrono::days>(time);
-    auto ymd = std::chrono::year_month_day(daypoint);           // calendar date
-    auto time_of_day = std::chrono::hh_mm_ss(time - daypoint);  // Yields time_of_day type
+    auto daypoint = floor<days>(time);
+    auto ymd = year_month_day(daypoint);           // calendar date
+    auto time_of_day = hh_mm_ss(time - daypoint);  // Yields time_of_day type
 
     // Obtain individual components as integers
     return {.year = int(ymd.year()),

src/task.cpp

@@ -28,9 +28,9 @@ auto Task::CalculateNext(TimePoint from) -> bool {
     auto result = schedule_.CalculateFrom(from);
 
     // In case the calculation fails, the task will no longer expire.
-    valid_ = std::get<0>(result);
+    valid_ = result.has_value();
     if (valid_) {
-        next_schedule_ = std::get<1>(result);
+        next_schedule_ = result.value();
 
         // Make sure that the task is allowed to run.
         last_run_ = next_schedule_ - 1s;

tests/data_test.cpp

@@ -190,11 +190,11 @@ SCENARIO("Date that exist in one of the months") { REQUIRE(Data::Create("0 0 * 3
 SCENARIO("Replacing text with numbers") {
     {
         std::string s = "SUN-TUE";
-        REQUIRE(Data::ReplaceStringNameWithNumeric<DayOfWeek>(s) == "0-2");
+        REQUIRE(details::ReplaceDayNameWithNumeric(s) == "0-2");
     }
 
     {
         std::string s = "JAN-DEC";
-        REQUIRE(Data::ReplaceStringNameWithNumeric<Months>(s) == "1-12");
+        REQUIRE(details::ReplaceMonthNameWithNumeric(s) == "1-12");
     }
 }