more cleanup

Author: BestITUserEUW

README.md

@@ -8,8 +8,10 @@ This library is completely based on [libcron](https://github.com/PerMalmberg/lib
 
 - Proper CMake support
 - date lib replaced with std::chrono implementation
-- Time zone clock
+- Time zone clock `TzClock`
 - Automated tests for (clang, gcc, msvc)
+- Correct Thread Safety Guarantees
+- Optional Cron Expression Caching
 
 ## Third party libraries
 
@@ -30,7 +32,7 @@ using namespace std::chrono_literals;
 auto main() -> int {
     oryx::chron::Scheduler scheduler;
 
-    scheduler.AddSchedule("Task-1", "* * * * * ?", [](auto&) { std::cout << "Hello World\n"; });
+    scheduler.AddSchedule("Task-1", "* * * * * ?", [](auto info) { std::cout << info.name << " called with delay" << task.delay << "\n"; });
     for (;;) {
         scheduler.Tick();
         std::this_thread::sleep_for(1s);
@@ -40,11 +42,7 @@ auto main() -> int {
 }
 ```
 
-In order to trigger execution of callbacks one must call `oryx::chron::Scheduler::Tick` at least once a second to prevent missing schedules.
-
-In case there is a lot of time between you call `AddSchedule` and `Tick`, you can call `RecalculateSchedule`.
-
-`oryx::chron::Taskinformation` offers a convenient API to retrieve further information:
+In order to trigger execution of callbacks one must call `oryx::chron::Scheduler::Tick` at least once a second to prevent missing schedules:
 
 ```cpp
 #include <thread>
@@ -58,9 +56,9 @@ using namespace std::chrono_literals;
 auto main() -> int {
     oryx::chron::Scheduler scheduler;
 
-    scheduler.AddSchedule("Task-1", "* * * * * ?", [](const oryx::chron::TaskInformation& task_info) {
-        if (task_info.GetDelay() >= 1s) {
-            std::cout << task_info.GetName() << ": my scheduler is ticking to slow\n";
+    scheduler.AddSchedule("Task-1", "* * * * * ?", [](const oryx::chron::TaskInfo& info) {
+        if (info.delay >= 1s) {
+            std::cout << info.name << ": my scheduler is ticking to slow\n";
         }
     });
     for (;;) {
@@ -72,64 +70,9 @@ auto main() -> int {
 }
 ```
 
-### Adding multiple tasks with individual schedules at once
-
-Add schedule needs to sort the underlying container each time you add a schedule. To improve performance when adding a batch of tasks by only sorting once you can also call AddSchedule with:
-
-- `std::map<std::string, std::string>`
-- `std::vector<std::pair<std::string, std::string>>`
-- `std::vector<std::tuple<std::string, std::string>>`
-- `std::unordered_map<std::string, std::string>`
-
-where the first element corresponds to the task name and the second element to the task schedule. Only if all schedules in the container are valid, they will be added to `oryx::chron::Scheduler`. The return type is a `std::tuple<bool, std::string, std::string>`, where the boolean is `true` if the schedules have been added or false otherwise. If the schedules have not been added, the second element in the tuple corresponds to the task-name with the given invalid schedule. If there are multiple invalid schedules in the container, `AddSchedule` will abort at the first invalid element
-
-```cpp
-#include <chrono>
-#include <thread>
-#include <iostream>
-#include <unordered_map>
-
-#include <oryx/chron.hpp>
-
-using namespace std::chrono_literals;
-
-auto main() -> int {
-    oryx::chron::Scheduler scheduler;
-
-    std::unordered_map<std::string, std::string> schedules;
-    for (int i = 1; i <= 50; i++) {
-        schedules["Task-" + std::to_string(i)] = "* * * * * ?";
-    }
-
-    auto res = scheduler.AddSchedule(schedules, [](const oryx::chron::TaskInformation& task_info) {
-        std::cout << task_info.GetName() << ": "
-                  << std::chrono::duration_cast<std::chrono::milliseconds>(task_info.GetDelay()) << "\n";
-    });
-
-    for (;;) {
-        scheduler.Tick();
-        std::this_thread::sleep_for(1s);
-    }
-
-    return 0;
-}
-```
-
-Adding multiple with an invalid schedule:
+### Adding a batch of schedules at once
 
-```cpp
-std::unordered_map<std::string, std::string> schedules;
-for (int i = 1; i <= 50; i++) {
-    schedules["Task-" + std::to_string(i)] = "* * * * * ?";
-}
-schedules["Task-50"] = "invalid";
-
-auto res = scheduler.AddSchedule(
-    schedules, [](const oryx::chron::TaskInformation& task_info) { std::cout << task_info.GetName(); });
-if (std::get<0>(res) == false) {
-    std::cout << "Task " << std::get<1>(res) << "has an invalid schedule: " << std::get<2>(res) << "\n";
-}
-```
+#### TODO
 
 
 
@@ -180,7 +123,7 @@ auto main() -> int {
     while (!stop_requested) {
         task_name = "Task-" + std::to_string(counter++);
         scheduler.AddSchedule(task_name, "* * * * * ?",
-                              [](auto& info) { std::cout << info.GetName() << ": Called\n"; });
+                              [](TaskInfo info) { std::cout << info.name << ": Called\n"; });
         std::cout << "Scheduled: " << task_name << "\n";
         std::this_thread::sleep_for(1s);
     }
@@ -233,7 +176,7 @@ auto main() -> int {
 
 This implementation supports cron format, as specified below. 
 
-Each schedule expression conststs of 6 parts, all mandatory. However, if 'day of month' specifies specific days, then 'day of week' is ignored.
+Each schedule expression consists of 6 parts, all mandatory. However, if 'day of month' specifies specific days, then 'day of week' is ignored.
 
 ```text
 ┌──────────────seconds (0 - 59)
@@ -302,7 +245,7 @@ These special time specification tokens which replace the 5 initial time and dat
 |Token|Meaning
 | --- | --- |
 | @yearly | Run once a year, ie.  "0 0 0 1 1 *".
-| @annually | Run once a year, ie.  "0 0 0 1 1 *"".
+| @annually | Run once a year, ie.  "0 0 0 1 1 *".
 | @monthly | Run once a month, ie. "0 0 0 1 * *".
 | @weekly | Run once a week, ie.  "0 0 0 * * 0".
 | @daily | Run once a day, ie.   "0 0 0 * * ?".

include/oryx/chron/chron_data.hpp

@@ -12,8 +12,8 @@ struct ChronData {
     std::set<Seconds> seconds;
     std::set<Minutes> minutes;
     std::set<Hours> hours;
-    std::set<Days> days;
-    std::set<Weeks> weeks;
+    std::set<MonthDays> days;
+    std::set<Weekdays> weeks;
     std::set<Months> months;
 };
 

include/oryx/chron/details/all_of.hpp

@@ -14,19 +14,16 @@ concept StaticCastableFromUInt8 = requires(uint8_t v) {
 };
 }  // namespace traits
 
-template <traits::StaticCastableFromUInt8 T>
-auto AnyOf(const std::set<T>& set, uint8_t low, uint8_t high) -> bool {
-    for (auto i = low; i <= high; ++i)
-        if (set.contains(static_cast<T>(i))) return true;
-    return false;
-}
-
 template <typename Enum>
     requires std::is_enum_v<Enum>
-auto AnyOf(const std::set<Enum>& set, Enum low, Enum high) -> bool {
-    for (auto i = details::to_underlying(low); i <= details::to_underlying(high); ++i)
-        if (set.contains(static_cast<Enum>(i))) return true;
-    return false;
+auto AnyOf(const std::set<Enum>& range, Enum low, Enum high) -> bool {
+    auto it = range.lower_bound(low);
+    return it != range.end() && *it <= high;
+}
+
+template <traits::StaticCastableFromUInt8 T>
+auto AnyOf(const std::set<T>& range, uint8_t low, uint8_t high) -> bool {
+    return AnyOf(range, static_cast<T>(low), static_cast<T>(high));
 }
 
 }  // namespace oryx::chron::details

include/oryx/chron/details/any_of.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <oryx/chron/traits.hpp>
+
 namespace oryx::chron::details {
 
 class NullMutex {
@@ -8,4 +10,6 @@ class NullMutex {
     void unlock() {}
 };
 
+static_assert(traits::BasicLockable<NullMutex>);
+
 }  // namespace oryx::chron::details

include/oryx/chron/details/null_mutex.hpp

@@ -2,6 +2,8 @@
 
 #include <set>
 #include <algorithm>
+#include <ranges>
+#include <type_traits>
 
 #include <oryx/chron/traits.hpp>
 #include <oryx/chron/chron_data.hpp>
@@ -148,31 +150,29 @@ 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 {
-        auto parts = details::StringSplit(s, ',');
-        return ProcessParts(parts, numbers);
+        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, ',');
-        for (auto& part : parts) {
-            details::ReplaceWithNumeric<T>(part, names);
-        }
+        std::ranges::for_each(parts, [&names](auto&& part) { details::ReplaceWithNumeric<T>(part, names); });
         return ProcessParts(parts, numbers);
     }
 
-    template <chron::traits::TimeType T>
-    static auto ProcessParts(std::span<const std::string> parts, std::set<T>& numbers) -> bool {
-        bool success{true};
-        for (auto& part : parts) {
-            success &= ConvertFromStringRangeToNumberRange(part, numbers);
-        }
-        return success;
-    }
-
     static auto CheckDomVsDow(std::string_view dom, std::string_view dow) -> bool {
         // Day of month and day of week are mutually exclusive so one of them must at always be ignored using
         // the '?'-character unless one field already is something other than '*'.
@@ -187,13 +187,13 @@ struct Parser {
 
     static auto ValidateDateVsMonths(const ChronData& data) -> bool {
         // Only February allowed? Ensure day_of_month includes only 1..29
-        if (data.months.size() == 1 && data.months.count(static_cast<Months>(2))) {
+        if (data.months.size() == 1 && data.months.contains(static_cast<Months>(2))) {
             if (!details::AnyOf(data.days, 1, 29)) return false;
         }
 
         // If only day 31 is selected, ensure at least one month allows it
-        if (data.days.size() == 1 && data.days.count(Days::Last)) {
-            if (!std::ranges::any_of(details::kMonthsWith31, [&data](Months m) { return data.months.count(m) > 0; })) {
+        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); })) {
                 return false;
             }
         }

include/oryx/chron/details/parser.hpp

@@ -1,25 +1,17 @@
 #pragma once
 
 #include <charconv>
-#include <stdexcept>
+#include <cassert>
 #include <string_view>
-#include <type_traits>
 
 namespace oryx::chron::details {
 
 template <typename T>
-inline auto StringCast(std::string_view sv) -> T {
+auto StringCast(std::string_view sv) -> T {
     T value{};
     auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), value);
-    if (ec != std::errc{}) throw std::invalid_argument("Invalid integer");
+    assert(ec == std::errc{} && "Casting to string failed misserably!");
     return value;
 }
 
-template <typename T>
-    requires std::is_enum_v<T>
-inline auto StringCast(std::string_view sv) -> T {
-    using _UT = std::underlying_type<T>;
-    return static_cast<T>(StringCast<_UT>(sv));
-}
-
 }  // namespace oryx::chron::details

include/oryx/chron/details/string_cast.hpp

@@ -63,7 +63,7 @@ auto ReplaceWithNumeric(std::string& data, NamesView names) -> std::string& {
 }
 
 inline auto ReplaceDayNameWithNumeric(std::string& data) -> std::string& {
-    return ReplaceWithNumeric<Weeks>(data, kDayNames);
+    return ReplaceWithNumeric<Weekdays>(data, kDayNames);
 }
 
 inline auto ReplaceMonthNameWithNumeric(std::string& data) -> std::string& {

include/oryx/chron/details/time_types.hpp

@@ -1,22 +1,13 @@
 #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);
+template <typename T>
+[[nodiscard]]
+constexpr auto to_underlying(T __value) noexcept -> std::underlying_type_t<T> {
+    return static_cast<std::underlying_type_t<T>>(__value);
 }
 
-#else
-
-using std::to_underlying;
-
-#endif
-
 }  // namespace oryx::chron::details