Implement delayed_by parameter to task callback.

* Adding functions to remove a specific schedule (by the given name) or all scheduled tasks from the Cron class.

* Update libcron/include/libcron/Task.h

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

* Update libcron/include/libcron/Task.h

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

* Update libcron/include/libcron/Cron.h

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

* Update libcron/include/libcron/Cron.h

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

* Update libcron/include/libcron/Cron.h

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

* Adding Multithreading support via template, adding documentation

* Apply suggestions from code review

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

* Finishing suggestions from code-review (renaming elements)

Co-authored-by: Per Malmberg <PerMalmberg@users.noreply.github.com>

CMakeLists.txt

@@ -1,5 +1,6 @@
 cmake_minimum_required(VERSION 3.6)
 
+project(top)
 add_subdirectory(libcron)
 add_subdirectory(test)
 

README.md

@@ -1,7 +1,63 @@
 # libcron
 A C++ scheduling library using cron formatting.
 
-# Local time vs UTC
+# Using the Scheduler
+
+Libcron offers an easy to use API to add callbacks with corresponding cron-formatted strings:
+
+```
+libcron::Cron cron;
+
+cron.add_schedule("Hello from Cron", "* * * * * ?", [](*/std::chrono::system_clock::duration delayed_by*/) {
+	std::cout << "Hello from libcron!" std::endl;
+});
+```
+
+To trigger the execution of callbacks, one must call `libcron::Cron::tick` at least once a second to prevent missing schedules:
+
+```
+while(true)
+{
+	cron.tick();
+	std::this_thread::sleep_for(500mS);
+}
+```
+
+## Removing schedules from `libcron::Cron`
+
+libcron::Cron offers two convenient functions to remove schedules:
+
+- `clear_schedules()` will remove all schedules
+- `remove_schedule(std::string)` will remove a specific schedule
+
+For example, `cron.remove_schedule("Hello from Cron")` will remove the previously added task.
+
+## Removing/Adding tasks at runtime in a multithreaded environment
+
+When Calling `libcron::Cron::tick` from another thread than `add_schedule`, `clear_schedule` and `remove_schedule`, one must take care to protect the internal resources of `libcron::Cron` so that tasks are not removed or added while `libcron::Cron` is iterating over the schedules. `libcron::Cron` can take care of that, you simply have to define your own aliases:
+
+```
+/* The default class uses NullLock, which does not lock the resources at runtime */
+template<typename ClockType = libcron::LocalClock, typename LockType = libcron::NullLock>
+class Cron
+{
+	...
+}
+
+/* Define an alias for a thread-safe Cron scheduler which automatically locks ressources when needed */ 
+using CronMt = libcron::Cron<libcron::LocalClock, libcron::Locker>
+
+CronMt cron;
+cron.add_schedule("Hello from Cron", "* * * * * ?", []() {
+	std::cout << "Hello from CronMt!" std::endl;
+});
+
+....
+```
+
+However, this comes with costs: Whenever you call `tick`, a `std::mutex` will be locked and unlocked.  So only use the `libcron::Locker` to protect resources when you really need too.
+
+## Local time vs UTC
 
 This library uses `std::chrono::system_clock::timepoint` as its time unit. While that is UTC by default, the Cron-class
 uses a `LocalClock` by default which offsets `system_clock::now()` by the current UTC-offset. If you wish to work in
@@ -55,6 +111,7 @@ Each part is separated by one or more whitespaces. It is thus important to keep
 * Invalid:
   * 0, 3, 40-50 * * * * ?
   
+
 `Day of month` and `day of week` are mutually exclusive so one of them must at always be ignored using
 the '?'-character to ensure that it is not possible to specify a statement which results in an impossible mix of these fields. 
 
@@ -86,4 +143,3 @@ when using randomization, i.e. mutual exclusiveness and no extra spaces.
 # Used Third party libraries
 
 Howard Hinnant's [date libraries](https://github.com/HowardHinnant/date/)
-

libcron/include/libcron/Cron.h

@@ -4,23 +4,44 @@
 #include <chrono>
 #include <queue>
 #include <memory>
+#include <mutex>
 #include "Task.h"
 #include "CronClock.h"
 
 namespace libcron
 {
-    template<typename ClockType>
+    class NullLock 
+    {
+        public:
+            void lock() {}
+            void unlock() {}
+    };
+
+    class Locker
+    {
+        public:
+            Locker() : lck(m, std::defer_lock) {}
+            void lock() { lck.lock(); }
+            void unlock() { lck.unlock(); }
+        private:
+            std::mutex m{};
+            std::unique_lock<std::mutex> lck;
+    };
+
+    template<typename ClockType, typename LockType>
     class Cron;
 
-    template<typename ClockType>
+    template<typename ClockType, typename LockType>
-    std::ostream& operator<<(std::ostream& stream, const Cron<ClockType>& c);
+    std::ostream& operator<<(std::ostream& stream, const Cron<ClockType, LockType>& c);
 
-    template<typename ClockType = libcron::LocalClock>
+    template<typename ClockType = libcron::LocalClock, typename LockType = libcron::NullLock>
     class Cron
     {
         public:
 
-            bool add_schedule(std::string name, const std::string& schedule, std::function<void()> work);
+            bool add_schedule(std::string name, const std::string& schedule, Task::TaskFunction work);
+            void clear_schedules();
+            void remove_schedule(const std::string& name);
 
             size_t count() const
             {
@@ -48,7 +69,7 @@ namespace libcron
             void get_time_until_expiry_for_tasks(
                     std::vector<std::tuple<std::string, std::chrono::system_clock::duration>>& status) const;
 
-            friend std::ostream& operator<<<>(std::ostream& stream, const Cron<ClockType>& c);
+            friend std::ostream& operator<<<>(std::ostream& stream, const Cron<ClockType, LockType>& c);
 
         private:
             class Queue
@@ -66,6 +87,50 @@ namespace libcron
                     {
                         return c;
                     }
+
+                    void clear()
+                    {
+                        lock.lock();
+
+                        while (!empty())
+                            pop();
+
+                        lock.unlock();
+                    }
+
+                    template<typename T>
+                    void remove(T to_remove)
+                    {
+                        lock.lock();
+
+                        /* Copy current elements */
+                        std::vector<Task> temp{};
+                        std::swap(temp, c);
+
+                        /* Refill with elements ensuring correct order by calling push */
+                        for (const auto& task : temp)
+                        {
+                            if (task != to_remove)
+                                push(task);
+                        }
+
+                        lock.unlock();
+                    }
+
+                    void lock_queue()
+                    {
+                        /* Do not allow to manipulate the Queue */
+                        lock.lock();
+                    }
+
+                    void release_queue()
+                    {
+                        /* Allow Access to the Queue Manipulating-Functions */
+                        lock.unlock();
+                    }
+                    
+                private:
+                    LockType lock;
             };
 
 
@@ -75,25 +140,39 @@ namespace libcron
             std::chrono::system_clock::time_point last_tick{};
     };
 
-    template<typename ClockType>
+    template<typename ClockType, typename LockType>
-    bool Cron<ClockType>::add_schedule(std::string name, const std::string& schedule, std::function<void()> work)
+    bool Cron<ClockType, LockType>::add_schedule(std::string name, const std::string& schedule, Task::TaskFunction work)
     {
         auto cron = CronData::create(schedule);
         bool res = cron.is_valid();
         if (res)
         {
+            tasks.lock_queue();
             Task t{std::move(name), CronSchedule{cron}, std::move(work)};
             if (t.calculate_next(clock.now()))
             {
                 tasks.push(t);
             }
+            tasks.release_queue();
         }
 
         return res;
     }
 
-    template<typename ClockType>
+    template<typename ClockType, typename LockType>
-    std::chrono::system_clock::duration Cron<ClockType>::time_until_next() const
+    void Cron<ClockType, LockType>::clear_schedules()
+    {
+        tasks.clear();
+    }
+    
+    template<typename ClockType, typename LockType>
+    void Cron<ClockType, LockType>::remove_schedule(const std::string& name)
+    {
+        tasks.remove(name);
+    }
+
+    template<typename ClockType, typename LockType>
+    std::chrono::system_clock::duration Cron<ClockType, LockType>::time_until_next() const
     {
         std::chrono::system_clock::duration d{};
         if (tasks.empty())
@@ -108,9 +187,10 @@ namespace libcron
         return d;
     }
 
-    template<typename ClockType>
+    template<typename ClockType, typename LockType>
-    size_t Cron<ClockType>::tick(std::chrono::system_clock::time_point now)
+    size_t Cron<ClockType, LockType>::tick(std::chrono::system_clock::time_point now)
     {
+        tasks.lock_queue();
         size_t res = 0;
 
         if(!first_tick)
@@ -189,11 +269,12 @@ namespace libcron
             }
         });
 
+        tasks.release_queue();
         return res;
     }
 
-    template<typename ClockType>
+    template<typename ClockType, typename LockType>
-    void Cron<ClockType>::get_time_until_expiry_for_tasks(std::vector<std::tuple<std::string,
+    void Cron<ClockType, LockType>::get_time_until_expiry_for_tasks(std::vector<std::tuple<std::string,
                                                           std::chrono::system_clock::duration>>& status) const
     {
         auto now = clock.now();
@@ -206,8 +287,8 @@ namespace libcron
                       });
     }
 
-    template<typename ClockType>
+    template<typename ClockType, typename LockType>
-    std::ostream& operator<<(std::ostream& stream, const Cron<ClockType>& c)
+    std::ostream& operator<<(std::ostream& stream, const Cron<ClockType, LockType>& c)
     {
         std::for_each(c.tasks.get_tasks().cbegin(), c.tasks.get_tasks().cend(),
                       [&stream, &c](const Task& t)

libcron/include/libcron/Task.h

@@ -11,16 +11,18 @@ namespace libcron
     class Task
     {
         public:
+            using TaskFunction = std::function<void(std::chrono::system_clock::duration)>;
 
-            Task(std::string name, const CronSchedule schedule, std::function<void()> task)
+            Task(std::string name, CronSchedule schedule, TaskFunction task)
                     : name(std::move(name)), schedule(std::move(schedule)), task(std::move(task))
             {
             }
 
             void execute(std::chrono::system_clock::time_point now)
             {
+                auto delay = now - last_run;
                 last_run = now;
-                task();
+                task(delay);
             }
 
             Task(const Task& other) = default;
@@ -50,8 +52,28 @@ namespace libcron
             std::string name;
             CronSchedule schedule;
             std::chrono::system_clock::time_point next_schedule;
-            std::function<void()> task;
+            TaskFunction task;
             bool valid = false;
             std::chrono::system_clock::time_point last_run = std::numeric_limits<std::chrono::system_clock::time_point>::min();
     };
 }
+
+inline bool operator==(const std::string &lhs, const libcron::Task &rhs)
+{
+    return lhs == rhs.get_name();
+}
+
+inline bool operator==(const libcron::Task &lhs, const std::string &rhs)
+{
+    return lhs.get_name() == rhs;
+}
+
+inline bool operator!=(const std::string &lhs, const libcron::Task &rhs)
+{
+    return !(lhs == rhs);
+}
+
+inline bool operator!=(const libcron::Task &lhs, const std::string &rhs)
+{
+    return !(lhs == rhs);
+}

libcron/src/CronSchedule.cpp

@@ -46,7 +46,7 @@ namespace libcron
                 //Add days until the current weekday is one of the allowed weekdays
                 year_month_weekday ymw = date::floor<days>(curr);
 
-                if (data.get_day_of_week().find(static_cast<DayOfWeek>(unsigned(ymw.weekday()))) ==
+                if (data.get_day_of_week().find(static_cast<DayOfWeek>(ymw.weekday().c_encoding())) ==
                     data.get_day_of_week().end())
                 {
                     sys_days s = ymd;

test/CronRandomizationTest.cpp

@@ -23,13 +23,13 @@ void test(const char* const random_schedule, bool expect_failure = false)
         if(expect_failure)
         {
             // Parsing of random might succeed, but it yields an invalid schedule.
-            auto r = std::get<0>(res) && cron.add_schedule("validate schedule", schedule, []() {});
+            auto r = std::get<0>(res) && cron.add_schedule("validate schedule", schedule, [](auto) {});
             REQUIRE_FALSE(r);
         }
         else
         {
             REQUIRE(std::get<0>(res));
-            REQUIRE(cron.add_schedule("validate schedule", schedule, []() {}));
+            REQUIRE(cron.add_schedule("validate schedule", schedule, [](auto) {}));
 
         }
     }

test/CronTest.cpp

@@ -35,7 +35,7 @@ SCENARIO("Adding a task")
         WHEN("Adding a task that runs every second")
         {
             REQUIRE(c.add_schedule("A task", "* * * * * ?",
-                                   [&expired]()
+                                   [&expired](auto)
                                    {
                                        expired = true;
                                    })
@@ -68,7 +68,7 @@ SCENARIO("Adding a task that expires in the future")
         Cron<> c;
         REQUIRE(c.add_schedule("A task",
                                create_schedule_expiring_in(c.get_clock().now(), hours{0}, minutes{0}, seconds{3}),
-                               [&expired]()
+                               [&expired](auto)
                                {
                                    expired = true;
                                })
@@ -110,7 +110,7 @@ SCENARIO("Task priority")
         Cron<> c;
         REQUIRE(c.add_schedule("Five",
                                create_schedule_expiring_in(c.get_clock().now(), hours{0}, minutes{0}, seconds{5}),
-                               [&_5_second_expired]()
+                               [&_5_second_expired](auto)
                                {
                                    _5_second_expired++;
                                })
@@ -118,7 +118,7 @@ SCENARIO("Task priority")
 
         REQUIRE(c.add_schedule("Three",
                                create_schedule_expiring_in(c.get_clock().now(), hours{0}, minutes{0}, seconds{3}),
-                               [&_3_second_expired]()
+                               [&_3_second_expired](auto)
                                {
                                    _3_second_expired++;
                                })
@@ -231,7 +231,7 @@ SCENARIO("Clock changes")
         clock.set(sys_days{2018_y / 05 / 05});
 
         // Every hour
-        REQUIRE(c.add_schedule("Clock change task", "0 0 * * * ?", []()
+        REQUIRE(c.add_schedule("Clock change task", "0 0 * * * ?", [](auto)
         {
         })
         );
@@ -309,7 +309,7 @@ SCENARIO("Multiple ticks per second")
     int run_count = 0;
 
     // Every 10 seconds
-    REQUIRE(c.add_schedule("Clock change task", "*/10 0 * * * ?", [&run_count]()
+    REQUIRE(c.add_schedule("Clock change task", "*/10 0 * * * ?", [&run_count](auto)
     {
         run_count++;
     })
@@ -333,5 +333,90 @@ SCENARIO("Multiple ticks per second")
         }
 
     }
-
+}
+
+SCENARIO("Delayed run")
+{
+    Cron<TestClock> c{};
+    auto& clock = c.get_clock();
+
+    auto now = sys_days{ 2018_y / 05 / 05 };
+    clock.set(now);
+
+    // 3 seconds past the minute
+    REQUIRE(c.add_schedule("Task that expires every 3 seconds", "3 * * * * ?", [](auto delayed_by)
+        {
+            // At four past the original time we're a second late.
+            REQUIRE(delayed_by >= seconds{ 1 });
+        })
+    );
+
+    c.tick(now + seconds{ 4 });
+}
+
+SCENARIO("Tasks can be added and removed from the scheduler")
+{
+    GIVEN("A Cron instance with no task")
+    {
+        Cron<> c;
+        auto expired = false;
+
+        WHEN("Adding 5 tasks that runs every second")
+        {
+            REQUIRE(c.add_schedule("Task-1", "* * * * * ?",
+                                   [&expired](auto)
+                                   {
+                                       expired = true;
+                                   })
+            );
+
+            REQUIRE(c.add_schedule("Task-2", "* * * * * ?",
+                                   [&expired](auto)
+                                   {
+                                       expired = true;
+                                   })
+            );
+
+            REQUIRE(c.add_schedule("Task-3", "* * * * * ?",
+                                   [&expired](auto)
+                                   {
+                                       expired = true;
+                                   })
+            );
+
+            REQUIRE(c.add_schedule("Task-4", "* * * * * ?",
+                                   [&expired](auto)
+                                   {
+                                       expired = true;
+                                   })
+            );
+
+            REQUIRE(c.add_schedule("Task-5", "* * * * * ?",
+                                   [&expired](auto)
+                                   {
+                                       expired = true;
+                                   })
+            );
+
+            THEN("Count is 5")
+            {
+                REQUIRE(c.count() == 5);
+            }
+            AND_THEN("Removing all scheduled tasks")
+            {
+                c.clear_schedules();
+                REQUIRE(c.count() == 0);
+            }
+            AND_THEN("Removing a task that does not exist")
+            {
+                c.remove_schedule("Task-6");
+                REQUIRE(c.count() == 5);
+            }
+            AND_THEN("Removing a task that does exist")
+            {
+                c.remove_schedule("Task-5");
+                REQUIRE(c.count() == 4);
+            }
+        }
+    }
 }