more changes

Author: BestITUserEUW

include/oryx/chron/chrono_types.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <chrono>
+
+namespace oryx::chron {
+
+using Clock = std::chrono::system_clock;
+using TimePoint = std::chrono::time_point<Clock>;
+using Duration = Clock::duration;
+
+}  // namespace oryx::chron

include/oryx/chron/clock.hpp

@@ -5,37 +5,35 @@
 #include <chrono>
 
 #include "traits.hpp"
+#include "chrono_types.h"
 
 namespace oryx::chron {
 
 class UTCClock {
 public:
-    auto Now() const -> std::chrono::system_clock::time_point { return std::chrono::system_clock::now(); }
-    auto UtcOffset(std::chrono::system_clock::time_point) const -> std::chrono::seconds {
-        using namespace std::chrono;
-        return 0s;
-    }
+    auto Now() const -> TimePoint { return Clock::now(); }
+    auto UtcOffset(TimePoint) const -> std::chrono::seconds { return std::chrono::seconds(0); }
 };
 
 class LocalClock {
 public:
-    auto Now() const -> std::chrono::system_clock::time_point {
-        auto now = std::chrono::system_clock::now();
+    auto Now() const -> TimePoint {
+        auto now = Clock::now();
         return now + UtcOffset(now);
     }
 
-    auto UtcOffset(std::chrono::system_clock::time_point now) const -> std::chrono::seconds;
+    auto UtcOffset(TimePoint now) const -> std::chrono::seconds;
 };
 
 class TzClock {
 public:
-    auto Now() const -> std::chrono::system_clock::time_point {
-        auto now = std::chrono::system_clock::now();
+    auto Now() const -> TimePoint {
+        auto now = Clock::now();
         return now + UtcOffset(now);
     }
 
     auto TrySetTimezone(std::string_view name) -> bool;
-    auto UtcOffset(std::chrono::system_clock::time_point now) const -> std::chrono::seconds;
+    auto UtcOffset(TimePoint now) const -> std::chrono::seconds;
 
 private:
     mutable std::mutex mtx_{};

include/oryx/chron/data.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstdint>
+#include <string>
 #include <set>
 #include <regex>
 #include <string>

include/oryx/chron/randomization.hpp

@@ -1,13 +1,8 @@
 #pragma once
 
 #include <string>
-#include <set>
 #include <tuple>
-#include <regex>
 #include <random>
-#include <utility>
-
-#include "data.hpp"
 
 namespace oryx::chron {
 class Randomization {
@@ -21,68 +16,8 @@ class Randomization {
     auto Parse(const std::string& cron_schedule) -> std::tuple<bool, std::string>;
 
 private:
-    template <typename T>
-    auto GetRandomInRange(const std::string& section,
-                          int& selected_value,
-                          std::pair<int, int> limit = std::make_pair(-1, -1)) -> std::pair<bool, std::string>;
-
-    auto DayLimiter(const std::set<Months>& month) -> std::pair<int, int>;
-    auto Cap(int value, int lower, int upper) -> int;
-
-    // Members
-    const std::regex rand_expression_{R"#([rR]\((\d+)\-(\d+)\))#", std::regex_constants::ECMAScript};
     std::random_device random_device_;
     std::mt19937 twister_;
 };
 
-template <typename T>
-auto Randomization::GetRandomInRange(const std::string& section, int& selected_value, std::pair<int, int> limit)
-    -> std::pair<bool, std::string> {
-    auto result = std::make_pair(true, std::string{});
-    selected_value = -1;
-
-    std::smatch random_match;
-
-    if (std::regex_match(section.cbegin(), section.cend(), random_match, rand_expression_)) {
-        // Random range, parse left and right numbers
-        auto left = std::stoi(random_match[1].str());
-        auto right = std::stoi(random_match[2].str());
-
-        // Apply limit if provided
-        if (limit.first != -1 && limit.second != -1) {
-            left = Cap(left, limit.first, limit.second);
-            right = Cap(right, limit.first, limit.second);
-        }
-
-        Data cron_data;
-        std::set<T> numbers;
-        result.first = cron_data.ConvertFromStringRangeToNumberRange<T>(
-            std::to_string(left) + "-" + std::to_string(right), numbers);
-
-        // Remove items outside the limit
-        if (limit.first != -1 && limit.second != -1) {
-            for (auto it = numbers.begin(); it != numbers.end();) {
-                if (Data::ValueOf(*it) < limit.first || Data::ValueOf(*it) > limit.second) {
-                    it = numbers.erase(it);
-                } else {
-                    ++it;
-                }
-            }
-        }
-
-        if (result.first && !numbers.empty()) {
-            // Select a random value from the valid numbers
-            std::uniform_int_distribution<> distribution(0, static_cast<int>(numbers.size() - 1));
-            auto it = numbers.begin();
-            std::advance(it, distribution(twister_));
-            selected_value = Data::ValueOf(*it);
-            result.second = std::to_string(selected_value);
-        }
-    } else {
-        // Not a random section, return as-is
-        result.second = section;
-    }
-
-    return result;
-}
 }  // namespace oryx::chron

include/oryx/chron/schedule.hpp

@@ -1,24 +1,20 @@
 #pragma once
 
-#include <chrono>
+#include <tuple>
 
 #include "data.hpp"
 #include "date_time.hpp"
+#include "chrono_types.h"
 
 namespace oryx::chron {
 class Schedule {
 public:
     explicit Schedule(Data data)
         : data_(std::move(data)) {}
 
-    Schedule(const Schedule&) = default;
+    auto CalculateFrom(const TimePoint& from) const -> std::tuple<bool, TimePoint>;
 
-    auto operator=(const Schedule&) -> Schedule& = default;
-
-    auto CalculateFrom(const std::chrono::system_clock::time_point& from) const
-        -> std::tuple<bool, std::chrono::system_clock::time_point>;
-
-    static auto ToCalendarTime(std::chrono::system_clock::time_point time) -> DateTime;
+    static auto ToCalendarTime(TimePoint time) -> DateTime;
 
 private:
     Data data_;

include/oryx/chron/scheduler.hpp

@@ -11,6 +11,7 @@
 #include "traits.hpp"
 #include "task.hpp"
 #include "clock.hpp"
+#include "chrono_types.h"
 
 namespace oryx::chron {
 namespace details {
@@ -27,7 +28,7 @@ template <traits::Clock ClockType = LocalClock, traits::BasicLockable LockType =
 class Scheduler {
 public:
     // Schedule management
-    auto AddSchedule(std::string name, const std::string& schedule, Task::TaskFunction work) -> bool {
+    auto AddSchedule(std::string name, const std::string& schedule, Task::TaskFn work) -> bool {
         auto data = Data::Create(schedule);
         if (!data.IsValid()) {
             return false;
@@ -45,7 +46,7 @@ class Scheduler {
     }
 
     template <typename Schedules = std::map<std::string, std::string>>
-    auto AddSchedule(const Schedules& name_schedule_map, Task::TaskFunction work)
+    auto AddSchedule(const Schedules& name_schedule_map, Task::TaskFn work)
         -> std::tuple<bool, std::string, std::string> {
         bool is_valid{true};
         std::tuple<bool, std::string, std::string> result{false, "", ""};
@@ -97,7 +98,7 @@ class Scheduler {
         for (auto& task : tasks_) task.CalculateNext(clock_.Now() + std::chrono::seconds(1));
     }
 
-    auto Tick(std::chrono::system_clock::time_point now) -> size_t {
+    auto Tick(TimePoint now) -> size_t {
         std::lock_guard lock{tasks_mtx_};
 
         size_t executed_count{};
@@ -142,7 +143,7 @@ class Scheduler {
 
     auto Tick() -> size_t { return Tick(clock_.Now()); }
 
-    auto TimeUntilNext() const -> std::chrono::system_clock::duration {
+    auto TimeUntilNext() const -> Duration {
         std::lock_guard lock{tasks_mtx_};
         if (tasks_.empty()) {
             return std::chrono::minutes::max();
@@ -153,8 +154,7 @@ class Scheduler {
     auto GetClock() -> ClockType& { return clock_; }
     auto GetNumTasks() const -> size_t { return tasks_.size(); }
 
-    void GetTimeUntilExpiryForTasks(
-        std::vector<std::tuple<std::string, std::chrono::system_clock::duration>>& status) const {
+    void GetTimeUntilExpiryForTasks(std::vector<std::tuple<std::string, Duration>>& status) const {
         std::lock_guard lock{tasks_mtx_};
         auto now = clock_.Now();
         status.clear();
@@ -170,7 +170,7 @@ class Scheduler {
     std::vector<Task> tasks_;
     mutable std::mutex tasks_mtx_;
     ClockType clock_;
-    std::chrono::system_clock::time_point last_tick_;
+    TimePoint last_tick_;
     bool first_tick_{true};
 };
 

include/oryx/chron/task.hpp

@@ -1,46 +1,46 @@
 #pragma once
 
 #include <functional>
-#include <chrono>
+#include <string>
 
 #include "schedule.hpp"
+#include "chrono_types.h"
 
 namespace oryx::chron {
 
 class TaskInformation {
 public:
     virtual ~TaskInformation() = default;
-    virtual auto GetDelay() const -> std::chrono::system_clock::duration = 0;
+    virtual auto GetDelay() const -> Duration = 0;
     virtual auto GetName() const -> std::string_view = 0;
 };
 
 class Task : public TaskInformation {
 public:
-    using TaskFunction = std::function<void(const TaskInformation &)>;
+    using TaskFn = std::function<void(const TaskInformation &)>;
 
-    Task(std::string name, Schedule schedule, TaskFunction task);
-    Task(const Task &other) = default;
+    Task(std::string name, Schedule schedule, TaskFn task);
 
     auto operator=(const Task &) -> Task & = default;
     auto operator>(const Task &other) const -> bool { return next_schedule_ > other.next_schedule_; }
     auto operator<(const Task &other) const -> bool { return next_schedule_ < other.next_schedule_; }
 
-    void Execute(std::chrono::system_clock::time_point now);
-    auto CalculateNext(std::chrono::system_clock::time_point from) -> bool;
-    auto TimeUntilExpiry(std::chrono::system_clock::time_point now) const -> std::chrono::system_clock::duration;
+    void Execute(TimePoint now);
+    auto CalculateNext(TimePoint from) -> bool;
+    auto TimeUntilExpiry(TimePoint now) const -> Duration;
 
-    auto IsExpired(std::chrono::system_clock::time_point now) const -> bool;
+    auto IsExpired(TimePoint now) const -> bool;
     auto GetName() const -> std::string_view override { return name_; }
-    auto GetDelay() const -> std::chrono::system_clock::duration override { return delay_; }
-    auto GetStatus(std::chrono::system_clock::time_point now) const -> std::string;
+    auto GetDelay() const -> Duration override { return delay_; }
+    auto GetStatus(TimePoint now) const -> std::string;
 
 private:
     std::string name_;
     Schedule schedule_;
-    TaskFunction task_;
-    std::chrono::system_clock::time_point next_schedule_;
-    std::chrono::system_clock::duration delay_;
-    std::chrono::system_clock::time_point last_run_;
+    TaskFn task_;
+    TimePoint next_schedule_;
+    Duration delay_;
+    TimePoint last_run_;
     bool valid_;
 };
 

include/oryx/chron/traits.hpp

@@ -3,12 +3,14 @@
 #include <chrono>
 #include <concepts>
 
+#include "chrono_types.h"
+
 namespace oryx::chron::traits {
 
 template <typename T>
-concept Clock = requires(const T& t, std::chrono::system_clock::time_point tp) {
+concept Clock = requires(const T& t, TimePoint tp) {
     // Must provide: Now() -> std::chrono::system_clock::time_point
-    { t.Now() } -> std::same_as<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/clock.cpp

@@ -13,7 +13,7 @@ using namespace std::chrono;
 
 namespace oryx::chron {
 
-auto LocalClock::UtcOffset(system_clock::time_point now) const -> seconds {
+auto LocalClock::UtcOffset(TimePoint now) const -> seconds {
 #ifdef WIN32
     (void)now;
 
@@ -51,7 +51,7 @@ auto TzClock::TrySetTimezone(std::string_view name) -> bool {
     return true;
 }
 
-auto TzClock::UtcOffset(system_clock::time_point now) const -> seconds {
+auto TzClock::UtcOffset(TimePoint now) const -> seconds {
     // If we don't have a timezone set we use utc
     std::lock_guard lock(mtx_);
     if (timezone_)