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>

.gitignore

@@ -34,3 +34,4 @@
 cmake-build-*
 .idea/workspace.xml
 out/*
+test/out*

.idea/codeStyles/Project.xml

@@ -1,29 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <Objective-C-extensions>
-      <file>
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Import" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Macro" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Typedef" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Enum" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Constant" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Global" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Struct" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="FunctionPredecl" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Function" />
-      </file>
-      <class>
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Property" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Synthesize" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InitMethod" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="StaticMethod" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InstanceMethod" />
-        <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="DeallocMethod" />
-      </class>
-      <extensions>
-        <pair source="cpp" header="h" fileNamingConvention="NONE" />
-        <pair source="c" header="h" fileNamingConvention="NONE" />
-      </extensions>
-    </Objective-C-extensions>
-  </code_scheme>
-</component>

.idea/vcs.xml

@@ -2,5 +2,6 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/libcron/externals/date" vcs="Git" />
   </component>
 </project>

CMakeLists.txt

@@ -1,7 +1,6 @@
 cmake_minimum_required(VERSION 3.6)
 
-set(OUTPUT_LOCATION ${CMAKE_CURRENT_LIST_DIR}/out/)
-
+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,19 +111,35 @@ 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 unless one field already is something other than '*'. 
 
-# Examples
+`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. 
+
+## Examples
 
 |Expression | Meaning
 | --- | --- |
 | * * * * * ? | Every second
-|0 0 12 * * MON-FRI | Every Weekday at noon
-|0 0 12 1/2 * ?	| Every 2 days, starting on the 1st at noon
+| 0 0 12 * * MON-FRI | Every Weekday at noon
+| 0 0 12 1/2 * ?	| Every 2 days, starting on the 1st at noon
 | 0 0 */12 ? * * | Every twelve hours
 
-# Third party libraries
+# Randomization
+
+The standard cron format does not allow for randomization, but with the use of `CronRandomization` you can generate random
+schedules using the following format: `R(range_start-range_end)`, where `range_start` and `range_end` follow the same rules
+as for a regular cron range (step-syntax is not supported). All the rules for a regular cron expression still applies
+when using randomization, i.e. mutual exclusiveness and no extra spaces.
+
+## Examples
+|Expression | Meaning
+| --- | --- |
+| 0 0 R(13-20) * * ? | On the hour, on a random hour 13-20, inclusive.
+| 0 0 0 ? * R(0-6) | A random weekday, every week, at midnight.
+| 0 R(45-15) */12 ? * * | A random minute between 45-15, inclusive, every 12 hours.
+|0 0 0 ? R(DEC-MAR) R(SAT-SUN)| On the hour, on a random month december to march, on a random weekday saturday to sunday. 
+
+
+# Used Third party libraries
 
 Howard Hinnant's [date libraries](https://github.com/HowardHinnant/date/)
-

libcron/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.6)
 project(libcron)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 
 if( MSVC )
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
@@ -9,22 +9,26 @@ else()
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
 endif()
 
-include_directories(${CMAKE_CURRENT_LIST_DIR}/externals/date/include)
-
 add_library(${PROJECT_NAME}
-        Cron.h
-        Task.h
-        CronData.h
-        TimeTypes.h
-        CronData.cpp
-        CronSchedule.cpp
-        CronSchedule.h
-        DateTime.h
-        Task.cpp
-        CronClock.h
-		CronClock.cpp)
+		include/libcron/Cron.h
+		include/libcron/CronClock.h
+		include/libcron/CronData.h
+		include/libcron/CronRandomization.h
+		include/libcron/CronSchedule.h
+		include/libcron/DateTime.h
+		include/libcron/Task.h
+		include/libcron/TimeTypes.h
+		src/CronClock.cpp
+		src/CronData.cpp
+		src/CronRandomization.cpp
+		src/CronSchedule.cpp
+		src/Task.cpp)
+
+target_include_directories(${PROJECT_NAME}
+		PRIVATE ${CMAKE_CURRENT_LIST_DIR}/externals/date/include
+		PUBLIC include)
 
 set_target_properties(${PROJECT_NAME} PROPERTIES
-        ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}"
-        LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}"
-        RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}")
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out/${CMAKE_BUILD_TYPE}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out/${CMAKE_BUILD_TYPE}"
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out/${CMAKE_BUILD_TYPE}")

libcron/TimeTypes.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace libcron
-{
-    enum class Seconds : int8_t
-    {
-            First = 0,
-            Last = 59
-    };
-
-    enum class Minutes : int8_t
-    {
-            First = 0,
-            Last = 59
-    };
-
-    enum class Hours : int8_t
-    {
-            First = 0,
-            Last = 23
-    };
-
-    enum class DayOfMonth : uint8_t
-    {
-            First = 1,
-            Last = 31
-    };
-
-    enum class Months : uint8_t
-    {
-            First = 1,
-            Last = 12
-    };
-
-    enum class DayOfWeek : uint8_t
-    {
-            // Sunday = 0 ... Saturday = 6
-            First = 0,
-            Last = 6,
-    };
-}

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>
-    std::ostream& operator<<(std::ostream& stream, const Cron<ClockType>& c);
+    template<typename ClockType, typename LockType>
+    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>
-    bool Cron<ClockType>::add_schedule(std::string name, const std::string& schedule, std::function<void()> work)
+    template<typename ClockType, typename LockType>
+    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>
-    std::chrono::system_clock::duration Cron<ClockType>::time_until_next() const
+    template<typename ClockType, typename LockType>
+    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>
-    size_t Cron<ClockType>::tick(std::chrono::system_clock::time_point now)
+    template<typename ClockType, typename LockType>
+    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>
-    void Cron<ClockType>::get_time_until_expiry_for_tasks(std::vector<std::tuple<std::string,
+    template<typename ClockType, typename LockType>
+    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>
-    std::ostream& operator<<(std::ostream& stream, const Cron<ClockType>& c)
+    template<typename ClockType, typename LockType>
+    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/CronData.h

@@ -4,16 +4,20 @@
 #include <regex>
 #include <string>
 #include <vector>
-#include "TimeTypes.h"
+#include <libcron/TimeTypes.h>
 
 namespace libcron
 {
     class CronData
     {
         public:
+            static const int NUMBER_OF_LONG_MONTHS = 7;
+            static const libcron::Months months_with_31[NUMBER_OF_LONG_MONTHS];
+
             static CronData create(const std::string& cron_expression);
 
-            CronData();
+            CronData() = default;
+
             CronData(const CronData&) = default;
 
             bool is_valid() const
@@ -61,6 +65,7 @@ namespace libcron
             static bool has_any_in_range(const std::set<T>& set, uint8_t low, uint8_t high)
             {
                 bool found = false;
+
                 for (auto i = low; !found && i <= high; ++i)
                 {
                     found |= set.find(static_cast<T>(i)) != set.end();
@@ -69,8 +74,13 @@ namespace libcron
                 return found;
             }
 
-        private:
+            template<typename T>
+            bool convert_from_string_range_to_number_range(const std::string& range, std::set<T>& numbers);
 
+            template<typename T>
+            static std::string& replace_string_name_with_numeric(std::string& s);
+
+        private:
             void parse(const std::string& cron_expression);
 
             template<typename T>
@@ -114,8 +124,8 @@ namespace libcron
             std::set<DayOfWeek> day_of_week{};
             bool valid = false;
 
-            std::vector<std::string> month_names;
-            std::vector<std::string> day_names;
+            static const std::vector<std::string> month_names;
+            static const std::vector<std::string> day_names;
 
             template<typename T>
             void add_full_range(std::set<T>& set);
@@ -142,20 +152,20 @@ namespace libcron
         for (const auto& name : names)
         {
             std::regex m(name, std::regex_constants::ECMAScript | std::regex_constants::icase);
-            for (size_t i = 0; i < parts.size(); ++i)
+
+            for (auto& part : parts)
             {
                 std::string replaced;
-                std::regex_replace(std::back_inserter(replaced), parts[i].begin(), parts[i].end(), m,
+                std::regex_replace(std::back_inserter(replaced), part.begin(), part.end(), m,
                                    std::to_string(value_of_first_name));
 
-                parts[i] = replaced;
+                part = replaced;
             }
 
             value_of_first_name++;
         }
 
         return process_parts(parts, numbers);
-
     }
 
     template<typename T>
@@ -163,60 +173,9 @@ namespace libcron
     {
         bool res = true;
 
-        T left;
-        T right;
-        uint8_t step_start;
-        uint8_t step;
-
         for (const auto& p : parts)
         {
-            if (p == "*" || p == "?")
-            {
-                // We treat the ignore-character '?' the same as the full range being allowed.
-                add_full_range<T>(numbers);
-            }
-            else if (is_number(p))
-            {
-                res &= add_number<T>(numbers, std::stoi(p));
-            }
-            else if (get_range<T>(p, left, right))
-            {
-                // A range can be written as both 1-22 or 22-1, meaning totally different ranges.
-                // First case is 1...22 while 22-1 is only four hours: 22, 23, 0, 1.
-                if (left <= right)
-                {
-                    for (auto v = value_of(left); v <= value_of(right); ++v)
-                    {
-                        res &= add_number(numbers, v);
-                    }
-                }
-                else
-                {
-                    // 'left' and 'right' are not in value order. First, get values between 'left' and T::Last, inclusive
-                    for (auto v = value_of(left); v <= value_of(T::Last); ++v)
-                    {
-                        res &= add_number(numbers, v);
-                    }
-
-                    // Next, get values between T::First and 'right', inclusive.
-                    for (auto v = value_of(T::First); v <= value_of(right); ++v)
-                    {
-                        res &= add_number(numbers, v);
-                    }
-                }
-            }
-            else if (get_step<T>(p, step_start, step))
-            {
-                // Add from step_start to T::Last with a step of 'step'
-                for (auto v = step_start; v <= value_of(T::Last); v += step)
-                {
-                    res &= add_number(numbers, v);
-                }
-            }
-            else
-            {
-                res = false;
-            }
+            res &= convert_from_string_range_to_number_range(p, numbers);
         }
 
         return res;
@@ -235,8 +194,8 @@ namespace libcron
 
         if (std::regex_match(s.begin(), s.end(), match, range))
         {
-            auto left = std::stoi(match[1].str().c_str());
-            auto right = std::stoi(match[2].str().c_str());
+            auto left = std::stoi(match[1].str());
+            auto right = std::stoi(match[2].str());
 
             if (is_within_limits<T>(left, right))
             {
@@ -263,16 +222,17 @@ namespace libcron
         if (std::regex_match(s.begin(), s.end(), match, range))
         {
             int raw_start;
-            if(match[1].str() == "*")
+
+            if (match[1].str() == "*")
             {
                 raw_start = value_of(T::First);
             }
             else
             {
-                raw_start = std::stoi(match[1].str().c_str());
+                raw_start = std::stoi(match[1].str());
             }
 
-            auto raw_step = std::stoi(match[2].str().c_str());
+            auto raw_step = std::stoi(match[2].str());
 
             if (is_within_limits<T>(raw_start, raw_start) && raw_step > 0)
             {
@@ -326,5 +286,100 @@ namespace libcron
                && is_between(high, value_of(T::First), value_of(T::Last));
     }
 
+    template<typename T>
+    bool CronData::convert_from_string_range_to_number_range(const std::string& range, std::set<T>& numbers)
+    {
+        T left;
+        T right;
+        uint8_t step_start;
+        uint8_t step;
 
+        bool res = true;
+
+        if (range == "*" || range == "?")
+        {
+            // We treat the ignore-character '?' the same as the full range being allowed.
+            add_full_range<T>(numbers);
+        }
+        else if (is_number(range))
+        {
+            res = add_number<T>(numbers, std::stoi(range));
+        }
+        else if (get_range<T>(range, left, right))
+        {
+            // A range can be written as both 1-22 or 22-1, meaning totally different ranges.
+            // First case is 1...22 while 22-1 is only four hours: 22, 23, 0, 1.
+            if (left <= right)
+            {
+                for (auto v = value_of(left); v <= value_of(right); ++v)
+                {
+                    res &= add_number(numbers, v);
+                }
+            }
+            else
+            {
+                // 'left' and 'right' are not in value order. First, get values between 'left' and T::Last, inclusive
+                for (auto v = value_of(left); v <= value_of(T::Last); ++v)
+                {
+                    res = add_number(numbers, v);
+                }
+
+                // Next, get values between T::First and 'right', inclusive.
+                for (auto v = value_of(T::First); v <= value_of(right); ++v)
+                {
+                    res = add_number(numbers, v);
+                }
+            }
+        }
+        else if (get_step<T>(range, step_start, step))
+        {
+            // Add from step_start to T::Last with a step of 'step'
+            for (auto v = step_start; v <= value_of(T::Last); v += step)
+            {
+                res = add_number(numbers, v);
+            }
+        }
+        else
+        {
+            res = false;
+        }
+
+        return res;
+    }
+
+    template<typename T>
+    std::string & CronData::replace_string_name_with_numeric(std::string& s)
+    {
+        auto value = static_cast<int>(T::First);
+
+        const std::vector<std::string>* name_source{};
+
+        static_assert(std::is_same<T, libcron::Months>()
+                      || std::is_same<T, libcron::DayOfWeek>(),
+                        "T must be either Months or DayOfWeek");
+
+        if constexpr (std::is_same<T, libcron::Months>())
+        {
+            name_source = &month_names;
+        }
+        else
+        {
+            name_source = &day_names;
+        }
+
+        for (const auto& name : *name_source)
+        {
+            std::regex m(name, std::regex_constants::ECMAScript | std::regex_constants::icase);
+
+            std::string replaced;
+
+            std::regex_replace(std::back_inserter(replaced), s.begin(), s.end(), m, std::to_string(value));
+
+            s = replaced;
+
+            ++value;
+        }
+
+        return s;
+    }
 }

libcron/include/libcron/CronRandomization.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <tuple>
+#include <random>
+#include <regex>
+#include <functional>
+#include "CronData.h"
+
+namespace libcron
+{
+    class CronRandomization
+    {
+        public:
+            std::tuple<bool, std::string> parse(const std::string& cron_schedule);
+
+            CronRandomization();
+
+            CronRandomization(const CronRandomization&) = delete;
+
+            CronRandomization & operator=(const CronRandomization &) = delete;
+
+        private:
+            template<typename T>
+            std::pair<bool, std::string> get_random_in_range(const std::string& section,
+                                                             int& selected_value,
+                                                             std::pair<int, int> limit = std::make_pair(-1, -1));
+
+            std::pair<int, int> day_limiter(const std::set<Months>& month);
+
+            int cap(int value, int lower, int upper);
+
+            std::regex const rand_expression{ R"#([rR]\((\d+)\-(\d+)\))#", std::regex_constants::ECMAScript };
+            std::random_device rd{};
+            std::mt19937 twister;
+    };
+
+    template<typename T>
+    std::pair<bool, std::string> CronRandomization::get_random_in_range(const std::string& section,
+                                                                        int& selected_value,
+                                                                        std::pair<int, int> limit)
+    {
+        auto res = 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, get left and right numbers.
+            auto left = std::stoi(random_match[1].str());
+            auto right = std::stoi(random_match[2].str());
+
+            if (limit.first != -1 && limit.second != -1)
+            {
+                left = cap(left, limit.first, limit.second);
+                right = cap(right, limit.first, limit.second);
+            }
+
+            libcron::CronData cd;
+            std::set<T> numbers;
+            res.first = cd.convert_from_string_range_to_number_range<T>(
+                    std::to_string(left) + "-" + std::to_string(right), numbers);
+
+            // Remove items outside limits.
+            if (limit.first != -1 && limit.second != -1)
+            {
+                for (auto it = numbers.begin(); it != numbers.end(); )
+                {
+                    if (CronData::value_of(*it) < limit.first || CronData::value_of(*it) > limit.second)
+                    {
+                        it = numbers.erase(it);
+                    }
+                    else
+                    {
+                        ++it;
+                    }
+                }
+            }
+
+            if (res.first)
+            {
+                // Generate random indexes to select one of the numbers in the range.
+                std::uniform_int_distribution<> dis(0, static_cast<int>(numbers.size() - 1));
+
+                // Select the random number to use as the schedule
+                auto it = numbers.begin();
+                std::advance(it, dis(twister));
+                selected_value = CronData::value_of(*it);
+                res.second = std::to_string(selected_value);
+            }
+        }
+        else
+        {
+            // Not random, just append input to output.
+            res.second = section;
+        }
+
+        return res;
+    }
+}

libcron/include/libcron/CronSchedule.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "CronData.h"
+#include "libcron/CronData.h"
 #include <chrono>
 #ifdef _WIN32
 #pragma warning(push)
@@ -11,7 +11,7 @@
 #pragma warning(pop)
 #endif
 
-#include "DateTime.h"
+#include "libcron/DateTime.h"
 
 namespace libcron
 {

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/include/libcron/TimeTypes.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdint>
+
+namespace libcron
+{
+    enum class Seconds : int8_t
+    {
+        First = 0,
+        Last = 59
+    };
+
+    enum class Minutes : int8_t
+    {
+        First = 0,
+        Last = 59
+    };
+
+    enum class Hours : int8_t
+    {
+        First = 0,
+        Last = 23
+    };
+
+    enum class DayOfMonth : uint8_t
+    {
+        First = 1,
+        Last = 31
+    };
+
+    enum class Months : uint8_t
+    {
+        First = 1,
+        January = First,
+        February,
+        March,
+        April,
+        May,
+        June,
+        July,
+        August,
+        September,
+        October,
+        November,
+        December = 12,
+        Last = December
+    };
+
+    enum class DayOfWeek : uint8_t
+    {
+        // Sunday = 0 ... Saturday = 6
+        First = 0,
+        Last = 6,
+    };
+}

libcron/src/CronClock.cpp

@@ -1,4 +1,4 @@
-#include "CronClock.h"
+#include "libcron/CronClock.h"
 
 #ifdef WIN32
 #ifndef NOMINMAX

libcron/src/CronData.cpp

@@ -1,10 +1,20 @@
 #include <date/date.h>
-#include "CronData.h"
+#include "libcron/CronData.h"
 
 using namespace date;
 
 namespace libcron
 {
+    const constexpr Months CronData::months_with_31[NUMBER_OF_LONG_MONTHS] = { Months::January,
+                                                                               Months::March,
+                                                                               Months::May,
+                                                                               Months::July,
+                                                                               Months::August,
+                                                                               Months::October,
+                                                                               Months::December };
+
+    const std::vector<std::string> CronData::month_names{ "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
+    const std::vector<std::string> CronData::day_names{ "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
 
     CronData CronData::create(const std::string& cron_expression)
     {
@@ -14,17 +24,11 @@ namespace libcron
         return c;
     }
 
-    CronData::CronData()
-            : month_names({"JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"}),
-              day_names({"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"})
-    {
-    }
-
     void CronData::parse(const std::string& cron_expression)
     {
         // First, split on white-space. We expect six parts.
-        std::regex split{R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#",
-                         std::regex_constants::ECMAScript};
+        std::regex split{ R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#",
+                          std::regex_constants::ECMAScript };
 
         std::smatch match;
 
@@ -48,13 +52,12 @@ namespace libcron
         std::string r = "[";
         r += token;
         r += "]";
-        std::regex splitter{r, std::regex_constants::ECMAScript};
+        std::regex splitter{ r, std::regex_constants::ECMAScript };
 
         std::copy(std::sregex_token_iterator(s.begin(), s.end(), splitter, -1),
                   std::sregex_token_iterator(),
                   std::back_inserter(res));
 
-
         return res;
     }
 
@@ -90,25 +93,15 @@ namespace libcron
             // Make sure that if the days contains only 31, at least one month allows that date.
             if (day_of_month.size() == 1 && day_of_month.find(DayOfMonth::Last) != day_of_month.end())
             {
-                std::vector<int32_t> months_with_31;
-                for (int32_t i = 1; i <= 12; ++i)
-                {
-                    auto ymd = 2018_y / i / date::last;
-                    if (unsigned(ymd.day()) == 31)
-                    {
-                        months_with_31.push_back(i);
-                    }
-                }
-
                 res = false;
-                for (size_t i = 0; !res && i < months_with_31.size(); ++i)
+
+                for (size_t i = 0; !res && i < NUMBER_OF_LONG_MONTHS; ++i)
                 {
-                    res = months.find(static_cast<Months>(months_with_31[i])) != months.end();
+                    res = months.find(months_with_31[i]) != months.end();
                 }
             }
         }
 
-
         return res;
     }
 
@@ -122,9 +115,9 @@ namespace libcron
         // '?' as the ignore flag, although it is functionally equivalent to '*'.
 
         auto check = [](const std::string& l, std::string r)
-        {
-            return l == "*" && (r != "*" || r == "?");
-        };
+                     {
+                         return l == "*" && (r != "*" || r == "?");
+                     };
 
         return (dom == "?" || dow == "?")
                || check(dom, dow)

libcron/src/CronRandomization.cpp

@@ -0,0 +1,140 @@
+#include <libcron/CronRandomization.h>
+
+#include <regex>
+#include <map>
+#include <array>
+#include <algorithm>
+#include <iterator>
+#include <libcron/TimeTypes.h>
+#include <libcron/CronData.h>
+
+namespace libcron
+{
+    CronRandomization::CronRandomization()
+            : twister(rd())
+    {
+    }
+
+    std::tuple<bool, std::string> CronRandomization::parse(const std::string& cron_schedule)
+    {
+        // Split on space to get each separate part, six parts expected
+        const std::regex split{ R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#",
+                                std::regex_constants::ECMAScript };
+
+        std::smatch all_sections;
+        auto res = std::regex_match(cron_schedule.cbegin(), cron_schedule.cend(), all_sections, split);
+
+        // Replace text with numbers
+        std::string working_copy{};
+
+        if (res)
+        {
+            // Merge seconds, minutes, hours and day of month back together
+            working_copy += all_sections[1].str();
+            working_copy += " ";
+            working_copy += all_sections[2].str();
+            working_copy += " ";
+            working_copy += all_sections[3].str();
+            working_copy += " ";
+            working_copy += all_sections[4].str();
+            working_copy += " ";
+
+            // Replace month names
+            auto month = all_sections[5].str();
+            CronData::replace_string_name_with_numeric<libcron::Months>(month);
+
+            working_copy += " ";
+            working_copy += month;
+
+            // Replace day names
+            auto dow = all_sections[6].str();
+            CronData::replace_string_name_with_numeric<libcron::DayOfWeek>(dow);
+
+            working_copy += " ";
+            working_copy += dow;
+        }
+
+        std::string final_cron_schedule{};
+
+        // Split again on space
+        res = res && std::regex_match(working_copy.cbegin(), working_copy.cend(), all_sections, split);
+
+        if (res)
+        {
+            int selected_value = -1;
+            auto second = get_random_in_range<Seconds>(all_sections[1].str(), selected_value);
+            res = second.first;
+            final_cron_schedule = second.second;
+
+            auto minute = get_random_in_range<Minutes>(all_sections[2].str(), selected_value);
+            res &= minute.first;
+            final_cron_schedule += " " + minute.second;
+
+            auto hour = get_random_in_range<Hours>(all_sections[3].str(), selected_value);
+            res &= hour.first;
+            final_cron_schedule += " " + hour.second;
+
+            // Do Month before DayOfMonth to allow capping the allowed range.
+            auto month = get_random_in_range<Months>(all_sections[5].str(), selected_value);
+            res &= month.first;
+
+            std::set<Months> month_range{};
+
+            if (selected_value == -1)
+            {
+                // Month is not specific, get the range.
+                CronData cr;
+                res &= cr.convert_from_string_range_to_number_range<Months>(all_sections[5].str(), month_range);
+            }
+            else
+            {
+                month_range.emplace(static_cast<Months>(selected_value));
+            }
+
+            auto limits = day_limiter(month_range);
+
+            auto day_of_month = get_random_in_range<DayOfMonth>(all_sections[4].str(),
+                    selected_value,
+                    limits);
+
+            res &= day_of_month.first;
+            final_cron_schedule += " " + day_of_month.second + " " + month.second;
+
+            auto day_of_week = get_random_in_range<DayOfWeek>(all_sections[6].str(), selected_value);
+            res &= day_of_week.first;
+            final_cron_schedule += " " + day_of_week.second;
+        }
+
+        return { res, final_cron_schedule };
+    }
+
+    std::pair<int, int> CronRandomization::day_limiter(const std::set<Months>& months)
+    {
+        int max = CronData::value_of(DayOfMonth::Last);
+
+        for (auto month : months)
+        {
+            if (month == Months::February)
+            {
+                // Limit to 29 days, possibly causing delaying schedule until next leap year.
+                max = std::min(max, 29);
+            }
+            else if (std::find(std::begin(CronData::months_with_31),
+                               std::end(CronData::months_with_31),
+                               month) == std::end(CronData::months_with_31))
+            {
+                // Not among the months with 31 days
+                max = std::min(max, 30);
+            }
+        }
+
+        auto res = std::pair<int, int>{ CronData::value_of(DayOfMonth::First), max };
+
+        return res;
+    }
+
+    int CronRandomization::cap(int value, int lower, int upper)
+    {
+        return std::max(std::min(value, upper), lower);
+    }
+}

libcron/src/CronSchedule.cpp

@@ -1,4 +1,4 @@
-#include "CronSchedule.h"
+#include "libcron/CronSchedule.h"
 #include <tuple>
 
 using namespace std::chrono;
@@ -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;

libcron/src/Task.cpp

@@ -1,5 +1,5 @@
 #include <iostream>
-#include "Task.h"
+#include "libcron/Task.h"
 
 using namespace std::chrono;
 

test/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.6)
 project(cron_test)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 
 if( MSVC )
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
@@ -18,11 +18,13 @@ include_directories(
 add_executable(
         ${PROJECT_NAME}
         CronDataTest.cpp
-        CronScheduleTest.cpp CronTest.cpp)
+        CronRandomizationTest.cpp
+		CronScheduleTest.cpp
+		CronTest.cpp)
 
 target_link_libraries(${PROJECT_NAME} libcron)
 
 set_target_properties(${PROJECT_NAME} PROPERTIES
-        ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}"
-        LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}"
-        RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}")
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out"
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out")

test/CronDataTest.cpp

@@ -2,8 +2,8 @@
 
 #include <catch.hpp>
 #include <date/date.h>
-#include <libcron/Cron.h>
-#include <libcron/CronData.h>
+#include <libcron/include/libcron/Cron.h>
+#include <libcron/include/libcron/CronData.h>
 
 using namespace libcron;
 using namespace date;
@@ -225,3 +225,16 @@ SCENARIO("Date that exist in one of the months")
 {
     REQUIRE(CronData::create("0 0 * 31 APR,MAY ?").is_valid());
 }
+
+SCENARIO("Replacing text with numbers")
+{
+    {
+        std::string s = "SUN-TUE";
+        REQUIRE(CronData::replace_string_name_with_numeric<libcron::DayOfWeek>(s) == "0-2");
+    }
+
+    {
+        std::string s = "JAN-DEC";
+        REQUIRE(CronData::replace_string_name_with_numeric<libcron::Months>(s) == "1-12");
+    }
+}

test/CronRandomizationTest.cpp

@@ -0,0 +1,180 @@
+#include <catch.hpp>
+#include <string>
+#include <unordered_map>
+#include <algorithm>
+#include <libcron/CronRandomization.h>
+#include <libcron/Cron.h>
+#include <iostream>
+
+using namespace libcron;
+const auto EXPECT_FAILURE = true;
+
+void test(const char* const random_schedule, bool expect_failure = false)
+{
+    libcron::CronRandomization cr;
+
+    for (int i = 0; i < 5000; ++i)
+    {
+        auto res = cr.parse(random_schedule);
+        auto schedule = std::get<1>(res);
+
+        Cron<> cron;
+
+        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) {});
+            REQUIRE_FALSE(r);
+        }
+        else
+        {
+            REQUIRE(std::get<0>(res));
+            REQUIRE(cron.add_schedule("validate schedule", schedule, [](auto) {}));
+
+        }
+    }
+}
+
+SCENARIO("Randomize all the things")
+{
+    const char* random_schedule = "R(0-59) R(0-59) R(0-23) R(1-31) R(1-12) ?";
+
+    GIVEN(random_schedule)
+    {
+        THEN("Only valid schedules generated")
+        {
+            test(random_schedule);
+        }
+    }
+}
+
+SCENARIO("Randomize all the things with reverse ranges")
+{
+    const char* random_schedule = "R(45-15) R(30-0) R(18-2) R(28-15) R(8-3) ?";
+
+    GIVEN(random_schedule)
+    {
+        THEN("Only valid schedules generated")
+        {
+            test(random_schedule);
+        }
+    }
+}
+
+SCENARIO("Randomize all the things - day of week")
+{
+    const char* random_schedule = "R(0-59) R(0-59) R(0-23) ? R(1-12) R(0-6)";
+
+    GIVEN(random_schedule)
+    {
+        THEN("Only valid schedules generated")
+        {
+            test(random_schedule);
+        }
+    }
+}
+
+SCENARIO("Randomize all the things with reverse ranges - day of week")
+{
+    const char* random_schedule = "R(45-15) R(30-0) R(18-2) ? R(8-3) R(4-1)";
+
+    GIVEN(random_schedule)
+    {
+        THEN("Only valid schedules generated")
+        {
+            test(random_schedule);
+        }
+    }
+}
+
+SCENARIO("Test readme examples")
+{
+    GIVEN("0 0 R(13-20) * * ?")
+    {
+        THEN("Valid schedule generated")
+        {
+            test("0 0 R(13-20) * * ?");
+        }
+    }
+
+    GIVEN("0 0 0 ? * R(0-6)")
+    {
+        THEN("Valid schedule generated")
+        {
+            test("0 0 0 ? * R(0-6)");
+        }
+    }
+
+    GIVEN("0 R(45-15) */12 ? * *")
+    {
+        THEN("Valid schedule generated")
+        {
+            test("0 R(45-15) */12 ? * *");
+        }
+    }
+}
+
+SCENARIO("Randomization using text versions of days and months")
+{
+    GIVEN("0 0 0 ? * R(TUE-FRI)")
+    {
+        THEN("Valid schedule generated")
+        {
+           test("0 0 0 ? * R(TUE-FRI)");
+        }
+    }
+
+    GIVEN("Valid schedule")
+    {
+        THEN("Valid schedule generated")
+        {
+            test("0 0 0 ? R(JAN-DEC) R(MON-FRI)");
+        }
+        AND_WHEN("Given 0 0 0 ? R(DEC-MAR) R(SAT-SUN)")
+        {
+            THEN("Valid schedule generated")
+            {
+                test("0 0 0 ? R(DEC-MAR) R(SAT-SUN)");
+            }
+        }
+        AND_THEN("Given 0 0 0 ? R(JAN-FEB) *")
+        {
+            THEN("Valid schedule generated")
+            {
+                test("0 0 0 ? R(JAN-FEB) *");
+            }
+        }
+        AND_THEN("Given 0 0 0 ? R(OCT-OCT) *")
+        {
+            THEN("Valid schedule generated")
+            {
+                test("0 0 0 ? R(OCT-OCT) *");
+            }
+        }
+    }
+
+    GIVEN("Invalid schedule")
+    {
+        THEN("No schedule generated")
+        {
+            // Day of month specified - not allowed with day of week
+            test("0 0 0 1 R(JAN-DEC) R(MON-SUN)", EXPECT_FAILURE);
+        }
+        AND_THEN("No schedule generated")
+        {
+            // Invalid range
+            test("0 0 0 ? R(JAN) *", EXPECT_FAILURE);
+        }
+        AND_THEN("No schedule generated")
+        {
+            // Days in month field
+            test("0 0 0 ? R(MON-TUE) *", EXPECT_FAILURE);
+        }
+        AND_THEN("No schedule generated")
+        {
+            // Month in day field
+            test("0 0 0 ? * R(JAN-JUN)", EXPECT_FAILURE);
+        }
+
+    }
+}

test/CronScheduleTest.cpp

@@ -1,7 +1,7 @@
 #include <catch.hpp>
 #include <chrono>
 #include <date/date.h>
-#include <libcron/Cron.h>
+#include <libcron/include/libcron/Cron.h>
 #include <iostream>
 
 using namespace libcron;

test/CronTest.cpp

@@ -1,5 +1,5 @@
 #include <catch.hpp>
-#include <libcron/Cron.h>
+#include <libcron/include/libcron/Cron.h>
 #include <thread>
 #include <iostream>
 
@@ -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);
+            }
+        }
+    }
 }

uncrustify.cfg

@@ -0,0 +1,214 @@
+# Uncrustify-0.67-87-d75a44aa9
+newlines                        = lf
+input_tab_size                  = 4
+output_tab_size                 = 4
+string_replace_tab_chars        = true
+utf8_bom                        = remove
+sp_arith                        = force
+sp_arith_additive               = force
+sp_assign                       = force
+sp_cpp_lambda_assign            = remove
+sp_cpp_lambda_paren             = remove
+sp_assign_default               = force
+sp_after_assign                 = force
+sp_enum_paren                   = force
+sp_enum_assign                  = force
+sp_enum_before_assign           = force
+sp_enum_after_assign            = force
+sp_pp_stringify                 = remove
+sp_before_pp_stringify          = remove
+sp_bool                         = force
+sp_compare                      = force
+sp_inside_paren                 = remove
+sp_paren_paren                  = remove
+sp_before_ptr_star              = remove
+sp_before_unnamed_ptr_star      = remove
+sp_between_ptr_star             = remove
+sp_after_ptr_star               = force
+sp_after_ptr_block_caret        = remove
+sp_after_ptr_star_qualifier     = force
+sp_after_ptr_star_func          = force
+sp_ptr_star_paren               = force
+sp_before_ptr_star_func         = force
+sp_before_byref                 = remove
+sp_before_unnamed_byref         = remove
+sp_after_byref                  = force
+sp_after_byref_func             = force
+sp_before_byref_func            = force
+sp_before_angle                 = remove
+sp_inside_angle                 = remove
+sp_angle_colon                  = force
+sp_after_angle                  = force
+sp_angle_paren_empty            = remove
+sp_angle_word                   = force
+sp_angle_shift                  = remove
+sp_permit_cpp11_shift           = true
+sp_before_sparen                = force
+sp_inside_sparen                = remove
+sp_inside_sparen_close          = remove
+sp_inside_sparen_open           = remove
+sp_after_sparen                 = force
+sp_sparen_brace                 = force
+sp_special_semi                 = remove
+sp_before_semi_for              = remove
+sp_before_semi_for_empty        = remove
+sp_after_semi                   = remove
+sp_after_semi_for_empty         = force
+sp_after_comma                  = force
+sp_before_ellipsis              = remove
+sp_after_class_colon            = force
+sp_before_class_colon           = force
+sp_after_constr_colon           = force
+sp_before_constr_colon          = force
+sp_after_operator               = remove
+sp_after_operator_sym           = remove
+sp_after_cast                   = remove
+sp_inside_paren_cast            = remove
+sp_cpp_cast_paren               = remove
+sp_sizeof_paren                 = remove
+sp_inside_braces_enum           = force
+sp_inside_braces_struct         = force
+sp_after_type_brace_init_lst_open = force
+sp_before_type_brace_init_lst_close = force
+sp_inside_type_brace_init_lst   = force
+sp_inside_braces_empty          = remove
+sp_type_func                    = force
+sp_type_brace_init_lst          = remove
+sp_func_proto_paren             = remove
+sp_func_proto_paren_empty       = remove
+sp_func_def_paren               = remove
+sp_inside_tparen                = remove
+sp_after_tparen_close           = remove
+sp_square_fparen                = remove
+sp_fparen_brace                 = force
+sp_fparen_dbrace                = force
+sp_func_call_paren              = remove
+sp_func_class_paren_empty       = remove
+sp_return_paren                 = remove
+sp_attribute_paren              = remove
+sp_defined_paren                = remove
+sp_throw_paren                  = remove
+sp_after_throw                  = force
+sp_catch_paren                  = force
+sp_oc_catch_paren               = force
+sp_else_brace                   = force
+sp_brace_else                   = force
+sp_before_dc                    = remove
+sp_after_dc                     = remove
+sp_before_nl_cont               = force
+sp_cond_question                = force
+sp_after_new                    = force
+sp_between_new_paren            = remove
+sp_inside_newop_paren           = force
+sp_inside_newop_paren_open      = remove
+sp_inside_newop_paren_close     = remove
+indent_columns                  = 4
+indent_with_tabs                = 0
+indent_align_string             = true
+indent_namespace                = true
+indent_namespace_level          = 4
+indent_class                    = true
+indent_constr_colon             = true
+indent_ctor_init                = 4
+indent_access_spec              = 0
+indent_access_spec_body         = true
+indent_cpp_lambda_body          = true
+indent_cpp_lambda_only_once     = true
+nl_assign_leave_one_liners      = true
+nl_class_leave_one_liners       = true
+nl_enum_leave_one_liners        = true
+nl_getset_leave_one_liners      = true
+nl_func_leave_one_liners        = true
+nl_cpp_lambda_leave_one_liners  = true
+nl_start_of_file                = remove
+nl_end_of_file                  = force
+nl_end_of_file_min              = 1
+nl_enum_brace                   = force
+nl_enum_class                   = remove
+nl_enum_class_identifier        = remove
+nl_if_brace                     = force
+nl_brace_else                   = force
+nl_elseif_brace                 = force
+nl_else_brace                   = force
+nl_else_if                      = remove
+nl_before_if_closing_paren      = remove
+nl_brace_finally                = force
+nl_finally_brace                = force
+nl_try_brace                    = force
+nl_for_brace                    = force
+nl_catch_brace                  = force
+nl_while_brace                  = force
+nl_do_brace                     = force
+nl_brace_while                  = force
+nl_enum_own_lines               = force
+nl_func_type_name               = remove
+nl_func_decl_empty              = remove
+nl_func_def_empty               = remove
+nl_func_call_empty              = remove
+nl_return_expr                  = remove
+nl_after_semicolon              = true
+nl_after_brace_close            = true
+nl_before_if                    = force
+nl_after_if                     = force
+nl_before_for                   = force
+nl_after_for                    = force
+nl_before_while                 = force
+nl_after_while                  = force
+nl_before_switch                = force
+nl_after_switch                 = force
+nl_before_synchronized          = force
+nl_after_synchronized           = force
+nl_before_do                    = force
+nl_after_do                     = force
+nl_max                          = 2
+nl_after_func_proto             = 2
+nl_after_func_proto_group       = 2
+nl_after_func_class_proto       = 2
+nl_after_func_class_proto_group = 2
+nl_before_func_body_def         = 2
+nl_before_func_body_proto       = 2
+nl_after_func_body              = 2
+nl_after_func_body_class        = 2
+nl_after_func_body_one_liner    = 1
+nl_before_block_comment         = 2
+nl_before_c_comment             = 2
+nl_before_cpp_comment           = 2
+nl_after_multiline_comment      = true
+nl_after_label_colon            = true
+nl_after_struct                 = 2
+nl_before_class                 = 2
+nl_after_class                  = 2
+nl_before_access_spec           = 1
+nl_after_access_spec            = 1
+nl_comment_func_def             = 1
+nl_after_try_catch_finally      = 2
+nl_around_cs_property           = 2
+nl_between_get_set              = 2
+eat_blanks_after_open_brace     = true
+eat_blanks_before_close_brace   = true
+nl_before_return                = true
+pos_arith                       = lead
+code_width                      = 120
+ls_for_split_full               = true
+ls_func_split_full              = true
+cmt_width                       = 120
+cmt_reflow_mode                 = 2
+cmt_indent_multi                = false
+cmt_c_group                     = true
+cmt_sp_after_star_cont          = 1
+mod_full_brace_do               = force
+mod_full_brace_for              = force
+mod_full_brace_function         = force
+mod_full_brace_if               = force
+mod_full_brace_nl_block_rem_mlcond = true
+mod_full_brace_while            = force
+mod_full_brace_using            = force
+mod_paren_on_return             = remove
+mod_remove_extra_semicolon      = true
+mod_sort_using                  = true
+mod_case_brace                  = force
+mod_remove_empty_return         = true
+pp_ignore_define_body           = true
+use_indent_func_call_param      = false
+# option(s) with 'not default' value: 209
+#