introduced bundled preprocessing

Author: BestITUserEUW

CMakeLists.txt

@@ -67,6 +67,7 @@ file(GLOB_RECURSE ORYX_CHRON_HEADERS
 target_sources(${PROJECT_NAME} 
     PRIVATE 
         src/clock.cpp
+        src/preprocessor.cpp
         src/randomization.cpp
         src/schedule.cpp
         src/task.cpp

include/oryx/chron/details/parser.hpp

@@ -9,8 +9,6 @@
 #include <oryx/chron/chron_data.hpp>
 #include <oryx/chron/time_types.hpp>
 
-#include "string_split.hpp"
-#include "time_types.hpp"
 #include "string_cast.hpp"
 #include "in_range.hpp"
 #include "to_underlying.hpp"
@@ -150,27 +148,11 @@ struct Parser {
         return false;  // Invalid format
     }
 
-    template <chron::traits::TimeType T>
-    static auto ProcessParts(auto&& parts, std::set<T>& numbers) -> bool {
-        return std::ranges::all_of(parts, [&numbers](auto&& part) {
-            if constexpr (std::is_convertible_v<decltype(part), std::string_view>)
-                return ConvertFromStringRangeToNumberRange<T>(part, numbers);
-            else
-                return ConvertFromStringRangeToNumberRange(std::string_view(&*part.begin(), part.size()), numbers);
-        });
-    }
-
     template <chron::traits::TimeType T>
     static auto ValidateNumeric(std::string_view s, std::set<T>& numbers) -> bool {
-        return ProcessParts(std::views::split(s, ','), numbers);
-    }
-
-    template <chron::traits::TimeType T>
-    static auto ValidateLiteral(const std::string& s, std::set<T>& numbers, std::span<const std::string_view> names)
-        -> bool {
-        auto parts = details::StringSplit(s, ',');
-        std::ranges::for_each(parts, [&names](auto&& part) { details::ReplaceWithNumeric<T>(part, names); });
-        return ProcessParts(parts, numbers);
+        return std::ranges::all_of(std::views::split(s, ','), [&numbers](auto&& part) {
+            return ConvertFromStringRangeToNumberRange(std::string_view(&*part.begin(), part.size()), numbers);
+        });
     }
 
     static auto CheckDomVsDow(std::string_view dom, std::string_view dow) -> bool {
@@ -193,7 +175,7 @@ struct Parser {
 
         // If only day 31 is selected, ensure at least one month allows it
         if (data.days.size() == 1 && data.days.contains(MonthDays::Last)) {
-            if (!std::ranges::any_of(details::kMonthsWith31, [&data](Months m) { return data.months.contains(m); })) {
+            if (!std::ranges::any_of(kMonthsWith31, [&data](Months m) { return data.months.contains(m); })) {
                 return false;
             }
         }

include/oryx/chron/details/string_split.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <oryx/chron/traits.hpp>
+
+namespace oryx::chron {
+
+template <traits::Processor... Ps>
+struct Processors;
+
+template <>
+struct Processors<> {
+    static void Process(std::string&) noexcept {}
+};
+
+template <traits::Processor Curr, traits::Processor... Rest>
+struct Processors<Curr, Rest...> {
+    static auto Process(std::string data) noexcept -> std::string {
+        if constexpr (sizeof...(Rest) == 0)
+            return Curr::Process(std::move(data));
+        else
+            return Processors<Rest...>::Process(Curr::Process(std::move(data)));
+    }
+};
+
+struct DollarExpressionProcessor {
+    static auto Process(std::string data) noexcept -> std::string;
+};
+
+struct WeekMonthDayLiteralProcessor {
+    static auto Process(std::string data) noexcept -> std::string;
+};
+
+template <traits::Processor... Ps>
+auto PreprocessExpression(std::string data) noexcept -> std::string {
+    return Processors<Ps...>::Process(data);
+}
+
+static_assert(traits::Processor<DollarExpressionProcessor>);
+static_assert(traits::Processor<WeekMonthDayLiteralProcessor>);
+
+}  // namespace oryx::chron

include/oryx/chron/details/time_types.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <array>
 
 namespace oryx::chron {
 
@@ -41,4 +42,7 @@ enum class Months : uint8_t {
     Last = December
 };
 
+inline constexpr std::array<Months, 7> kMonthsWith31{Months::January, Months::March,   Months::May,     Months::July,
+                                                     Months::August,  Months::October, Months::December};
+
 }  // namespace oryx::chron

include/oryx/chron/preprocessor.hpp

@@ -4,6 +4,7 @@
 #include <concepts>
 #include <optional>
 #include <string_view>
+#include <type_traits>
 
 #include "chrono_types.hpp"
 #include "chron_data.hpp"
@@ -33,4 +34,9 @@ concept Parser = requires(T t, std::string_view sv) {
     { t(sv) } -> std::same_as<std::optional<ChronData>>;
 };
 
+template <typename T>
+concept Processor = requires(T t, std::string s) {
+    { T::Process(s) };
+};
+
 }  // namespace oryx::chron::traits

include/oryx/chron/time_types.hpp

@@ -3,44 +3,29 @@
 #include <optional>
 
 #include <oryx/chron/details/parser.hpp>
+#include <oryx/chron/preprocessor.hpp>
 
 namespace oryx::chron {
-namespace {
-
-struct DollarExprPair {
-    std::string_view expr;
-    std::string_view cron;
-};
-
-}  // namespace
 
 auto ExpressionParser::operator()(std::string_view cron_expression) const -> std::optional<ChronData> {
-    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"),
-        DollarExprPair("@daily", "0 0 0 * * ?"),   DollarExprPair("@hourly", "0 0 * * * ?")};
-
-    if (!cron_expression.empty() && cron_expression[0] == '@') {
-        auto it = std::ranges::find(kShortcuts, cron_expression, &DollarExprPair::expr);
-        if (it != kShortcuts.end()) [[likely]] {
-            cron_expression = it->cron;
-        }
+    static constexpr auto matcher = ctre::match<R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#">;
+
+    auto preprocessed =
+        PreprocessExpression<DollarExpressionProcessor, WeekMonthDayLiteralProcessor>(std::string(cron_expression));
+    auto match = matcher(std::move(preprocessed));
+    if (!match) [[unlikely]] {
+        return std::nullopt;
     }
 
-    bool valid{};
     ChronData data{};
-    if (auto match = ctre::match<R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#">(cron_expression))
-        [[likely]] {
-        valid = details::Parser::ValidateNumeric<Seconds>(match.get<1>().to_view(), data.seconds);
-        valid &= details::Parser::ValidateNumeric<Minutes>(match.get<2>().to_view(), data.minutes);
-        valid &= details::Parser::ValidateNumeric<Hours>(match.get<3>().to_view(), data.hours);
-        valid &= details::Parser::ValidateNumeric<MonthDays>(match.get<4>().to_view(), data.days);
-        valid &=
-            details::Parser::ValidateLiteral<Months>(match.get<5>().to_string(), data.months, details::kMonthNames);
-        valid &= details::Parser::ValidateLiteral<Weekdays>(match.get<6>().to_string(), data.weeks, details::kDayNames);
-        valid &= details::Parser::CheckDomVsDow(match.get<4>().to_view(), match.get<6>().to_view());
-        valid &= details::Parser::ValidateDateVsMonths(data);
-    }
+    bool valid = details::Parser::ValidateNumeric<Seconds>(match.get<1>().to_view(), data.seconds);
+    valid &= details::Parser::ValidateNumeric<Minutes>(match.get<2>().to_view(), data.minutes);
+    valid &= details::Parser::ValidateNumeric<Hours>(match.get<3>().to_view(), data.hours);
+    valid &= details::Parser::ValidateNumeric<MonthDays>(match.get<4>().to_view(), data.days);
+    valid &= details::Parser::ValidateNumeric<Months>(match.get<5>().to_view(), data.months);
+    valid &= details::Parser::ValidateNumeric<Weekdays>(match.get<6>().to_view(), data.weeks);
+    valid &= details::Parser::CheckDomVsDow(match.get<4>().to_view(), match.get<6>().to_view());
+    valid &= details::Parser::ValidateDateVsMonths(data);
 
     if (!valid) [[unlikely]] {
         return std::nullopt;

include/oryx/chron/traits.hpp

@@ -0,0 +1,94 @@
+#include <oryx/chron/preprocessor.hpp>
+
+#include <algorithm>
+#include <string_view>
+#include <span>
+
+#include <oryx/chron/details/ctre.hpp>
+#include <oryx/chron/details/to_underlying.hpp>
+
+namespace oryx::chron {
+namespace {
+
+struct DollarExpressionPair {
+    std::string_view expr;
+    std::string_view cron;
+};
+
+template <typename Enum>
+    requires std::is_enum_v<Enum>
+auto ReplaceWithNumeric(std::string data, std::span<const std::string_view> 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 = details::to_underlying(Enum::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;
+}
+
+}  // namespace
+
+auto DollarExpressionProcessor::Process(std::string data) noexcept -> std::string {
+    static constexpr std::array<DollarExpressionPair, 6> kExpressions{
+        DollarExpressionPair("@yearly", "0 0 0 1 1 *"),  DollarExpressionPair("@annually", "0 0 0 1 1 *"),
+        DollarExpressionPair("@monthly", "0 0 0 1 * *"), DollarExpressionPair("@weekly", "0 0 0 * * 0"),
+        DollarExpressionPair("@daily", "0 0 0 * * ?"),   DollarExpressionPair("@hourly", "0 0 * * * ?")};
+
+    if (!data.empty() && data[0] == '@') {
+        auto it = std::ranges::find(kExpressions, data, &DollarExpressionPair::expr);
+        if (it != kExpressions.end()) [[likely]] {
+            return std::string(it->cron);
+        }
+    }
+    return data;
+}
+
+auto WeekMonthDayLiteralProcessor::Process(std::string data) noexcept -> std::string {
+    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"};
+    static constexpr auto matcher = ctre::match<R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#">;
+
+    auto match = matcher(data);
+    if (!match) [[unlikely]] {
+        return data;
+    }
+
+    auto month = ReplaceWithNumeric<Months>(match.get<5>().to_string(), kMonthNames);
+    auto dow = ReplaceWithNumeric<Weekdays>(match.get<6>().to_string(), kDayNames);
+    return std::format("{} {} {} {} {} {}", match.get<1>().to_view(), match.get<2>().to_view(),
+                       match.get<3>().to_view(), match.get<4>().to_view(), month, dow);
+}
+
+}  // namespace oryx::chron