Merge pull request #2 from PerMalmberg/feature/1-add-randomization

Feature/1 add randomization

.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,5 @@
 cmake_minimum_required(VERSION 3.6)
 
-set(OUTPUT_LOCATION ${CMAKE_CURRENT_LIST_DIR}/out/)
-
 add_subdirectory(libcron)
 add_subdirectory(test)
 

README.md

@@ -56,18 +56,33 @@ Each part is separated by one or more whitespaces. It is thus important to keep
   * 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 '*'. 
+the '?'-character to ensure that it is not possible to specify a statement which results in an impossible mix of these fields. 
 
-# Examples
+## Examples
 
 |Expression | Meaning
 | --- | --- |
 | * * * * * ? | Every second
-|0 0 12 * * MON-FRI | Every Weekday 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 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 with the addition that only numbers are allowed. All the rules for a regular cron expression 
+still applies when using randomization, i.e. mutual exclusiveness and not 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.
+
+
+# Used Third party libraries
 
 Howard Hinnant's [date libraries](https://github.com/HowardHinnant/date/)
 

libcron/CMakeLists.txt

@@ -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
+		include/libcron/Cron.h
-        Task.h
+		include/libcron/CronClock.h
-        CronData.h
+		include/libcron/CronData.h
-        TimeTypes.h
+		include/libcron/CronRandomization.h
-        CronData.cpp
+		include/libcron/CronSchedule.h
-        CronSchedule.cpp
+		include/libcron/DateTime.h
-        CronSchedule.h
+		include/libcron/Task.h
-        DateTime.h
+		include/libcron/TimeTypes.h
-        Task.cpp
+		src/CronClock.cpp
-        CronClock.h
+		src/CronData.cpp
-		CronClock.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}"
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out"
-        LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out"
-        RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}")
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out")

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/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(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,10 @@ namespace libcron
                 return found;
             }
 
-        private:
+            template<typename T>
+            bool convert_from_string_range_to_number_range(const std::string& range, std::set<T>& numbers);
 
+        private:
             void parse(const std::string& cron_expression);
 
             template<typename T>
@@ -142,20 +149,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 +170,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 == "?")
+            res &= convert_from_string_range_to_number_range(p, numbers);
-            {
-                // 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;
-            }
         }
 
         return res;
@@ -235,8 +191,8 @@ namespace libcron
 
         if (std::regex_match(s.begin(), s.end(), match, range))
         {
-            auto left = std::stoi(match[1].str().c_str());
+            auto left = std::stoi(match[1].str());
-            auto right = std::stoi(match[2].str().c_str());
+            auto right = std::stoi(match[2].str());
 
             if (is_within_limits<T>(left, right))
             {
@@ -263,16 +219,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 +283,64 @@ 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;
+    }
 }

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.begin(), section.end(), 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,17 +1,17 @@
 #pragma once
 
-#include "CronData.h"
+#include "libcron/CronData.h"
 #include <chrono>
-#ifdef _WIN32
+#ifdef _WIN32
-#pragma warning(push)
+#pragma warning(push)
-#pragma warning(disable:4244)
+#pragma warning(disable:4244)
-#endif
+#endif
-#include <date/date.h>
+#include <date/date.h>
-#ifdef _WIN32
+#ifdef _WIN32
-#pragma warning(pop)
+#pragma warning(pop)
 #endif
 
-#include "DateTime.h"
+#include "libcron/DateTime.h"
 
 namespace libcron
 {

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,8 +1,8 @@
-#include "CronClock.h"
+#include "libcron/CronClock.h"
 
 #ifdef WIN32
-#ifndef NOMINMAX
+#ifndef NOMINMAX
-#define NOMINMAX
+#define NOMINMAX
 #endif
 #define WIN32_LEAN_AND_MEAN 
 #include <Windows.h>

libcron/src/CronData.cpp

@@ -1,10 +1,17 @@
 #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 };
 
     CronData CronData::create(const std::string& cron_expression)
     {
@@ -15,16 +22,16 @@ namespace libcron
     }
 
     CronData::CronData()
-            : month_names({"JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"}),
+            : month_names({ "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" }),
-              day_names({"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"})
+              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 split{ R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#",
-                         std::regex_constants::ECMAScript};
+                          std::regex_constants::ECMAScript };
 
         std::smatch match;
 
@@ -48,13 +55,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 +96,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,12 +118,12 @@ 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)
                || check(dow, dom);
     }
-}
+}

libcron/src/CronRandomization.cpp

@@ -0,0 +1,108 @@
+#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
+        std::regex split{ R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#",
+                          std::regex_constants::ECMAScript };
+
+        std::smatch all_sections;
+
+        std::string final_cron_schedule;
+
+        auto res = std::regex_match(cron_schedule.begin(), cron_schedule.end(), 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;

libcron/src/Task.cpp

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

test/CMakeLists.txt

@@ -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}"
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out"
-        LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/out"
-        RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_LOCATION}")
+        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/include/libcron/Cron.h>
-#include <libcron/CronData.h>
+#include <libcron/include/libcron/CronData.h>
 
 using namespace libcron;
 using namespace date;

test/CronRandomizationTest.cpp

@@ -0,0 +1,105 @@
+#include <catch.hpp>
+#include <string>
+#include <unordered_map>
+#include <algorithm>
+#include <libcron/CronRandomization.h>
+#include <libcron/Cron.h>
+#include <iostream>
+
+using namespace libcron;
+
+void test(const char* const random_schedule)
+{
+    libcron::CronRandomization cr;
+    std::unordered_map<int, std::unordered_map<int, int>> results{};
+
+    for (int i = 0; i < 5000; ++i)
+    {
+        auto res = cr.parse(random_schedule);
+        REQUIRE(std::get<0>(res));
+        auto schedule = std::get<1>(res);
+
+        INFO("schedule:" << schedule);
+        Cron<> cron;
+        REQUIRE(cron.add_schedule("validate schedule", schedule, []() {}));
+    }
+}
+
+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 ? * *");
+        }
+    }
+}

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>
 

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
+#