mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-11 21:01:29 +00:00
2a6cf8c8e7
* [Strings] Add more number formatters # Notes - Adds `Strings::ToUnsignedInt` for `uint32` support. - Adds `Strings::ToBigInt` for `int64` support. - Adds `Strings::ToUnsignedBigInt` for `uint64` support. - Adds `Strings::ToFloat` for `float` support. - Replaces all `std::stoi` references with `Strings::ToInt`. - Replaces all `atoi` references with `Strings::ToInt`. - Replaces all `std::stoul` references with `Strings::ToUnsignedInt`. - Replaces all `atoul` references with `Strings::ToUnsignedInt`. - Replaces all `std::stoll` references with `Strings::ToBigInt`. - Replaces all `atoll` references with `Strings::ToBigInt`. - Replaces all `std::stoull` references with `Strings::ToUnsignedBigInt`. - Replaces all `atoull` references with `Strings::ToUnsignedBigInt`. - Replaces all `std::stof` references with `Strings::ToFloat`. * [Strings] Add more number formatters - Adds `Strings::ToUnsignedInt` for `uint32` support. - Adds `Strings::ToBigInt` for `int64` support. - Adds `Strings::ToUnsignedBigInt` for `uint64` support. - Adds `Strings::ToFloat` for `float` support. - Replaces all `std::stoi` references with `Strings::ToInt`. - Replaces all `atoi` references with `Strings::ToInt`. - Replaces all `std::stoul` references with `Strings::ToUnsignedInt`. - Replaces all `atoul` references with `Strings::ToUnsignedInt`. - Replaces all `std::stoll` references with `Strings::ToBigInt`. - Replaces all `atoll` references with `Strings::ToBigInt`. - Replaces all `std::stoull` references with `Strings::ToUnsignedBigInt`. - Replaces all `atoull` references with `Strings::ToUnsignedBigInt`. - Replaces all `std::stof` references with `Strings::ToFloat`. * Rebase cleanup * Changes/benchmarks/tests --------- Co-authored-by: Akkadius <akkadius1@gmail.com>
877 lines
21 KiB
C++
877 lines
21 KiB
C++
#pragma once
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <bitset>
|
|
#include <cctype>
|
|
#include <ctime>
|
|
#include <iomanip>
|
|
#include <algorithm>
|
|
|
|
#if __cplusplus > 201402L
|
|
#include <string_view>
|
|
#define CRONCPP_IS_CPP17
|
|
#endif
|
|
|
|
namespace cron
|
|
{
|
|
#ifdef CRONCPP_IS_CPP17
|
|
#define HAS_STRING_VIEW
|
|
#define STRING_VIEW std::string_view
|
|
#define STRING_VIEW_NPOS std::string_view::npos
|
|
#define CONSTEXPTR constexpr
|
|
#else
|
|
#define STRING_VIEW std::string const &
|
|
#define STRING_VIEW_NPOS std::string::npos
|
|
#define CONSTEXPTR
|
|
#endif
|
|
|
|
using cron_int = uint8_t;
|
|
|
|
constexpr std::time_t INVALID_TIME = static_cast<std::time_t>(-1);
|
|
|
|
constexpr size_t INVALID_CRON_INDEX = static_cast<size_t>(-1);
|
|
|
|
class cronexpr;
|
|
|
|
namespace detail
|
|
{
|
|
enum class cron_field
|
|
{
|
|
second,
|
|
minute,
|
|
hour_of_day,
|
|
day_of_week,
|
|
day_of_month,
|
|
month,
|
|
year
|
|
};
|
|
|
|
template <typename Traits>
|
|
static bool find_next(cronexpr const & cex,
|
|
std::tm& date,
|
|
size_t const dot);
|
|
}
|
|
|
|
struct bad_cronexpr : public std::runtime_error
|
|
{
|
|
public:
|
|
explicit bad_cronexpr(STRING_VIEW message) :
|
|
std::runtime_error(message.data())
|
|
{}
|
|
};
|
|
|
|
|
|
struct cron_standard_traits
|
|
{
|
|
static const cron_int CRON_MIN_SECONDS = 0;
|
|
static const cron_int CRON_MAX_SECONDS = 59;
|
|
|
|
static const cron_int CRON_MIN_MINUTES = 0;
|
|
static const cron_int CRON_MAX_MINUTES = 59;
|
|
|
|
static const cron_int CRON_MIN_HOURS = 0;
|
|
static const cron_int CRON_MAX_HOURS = 23;
|
|
|
|
static const cron_int CRON_MIN_DAYS_OF_WEEK = 0;
|
|
static const cron_int CRON_MAX_DAYS_OF_WEEK = 6;
|
|
|
|
static const cron_int CRON_MIN_DAYS_OF_MONTH = 1;
|
|
static const cron_int CRON_MAX_DAYS_OF_MONTH = 31;
|
|
|
|
static const cron_int CRON_MIN_MONTHS = 1;
|
|
static const cron_int CRON_MAX_MONTHS = 12;
|
|
|
|
static const cron_int CRON_MAX_YEARS_DIFF = 4;
|
|
|
|
#ifdef CRONCPP_IS_CPP17
|
|
static const inline std::vector<std::string> DAYS = { "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
|
|
static const inline std::vector<std::string> MONTHS = { "NIL", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
|
|
#else
|
|
static std::vector<std::string>& DAYS()
|
|
{
|
|
static std::vector<std::string> days = { "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
|
|
return days;
|
|
}
|
|
|
|
static std::vector<std::string>& MONTHS()
|
|
{
|
|
static std::vector<std::string> months = { "NIL", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
|
|
return months;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
struct cron_oracle_traits
|
|
{
|
|
static const cron_int CRON_MIN_SECONDS = 0;
|
|
static const cron_int CRON_MAX_SECONDS = 59;
|
|
|
|
static const cron_int CRON_MIN_MINUTES = 0;
|
|
static const cron_int CRON_MAX_MINUTES = 59;
|
|
|
|
static const cron_int CRON_MIN_HOURS = 0;
|
|
static const cron_int CRON_MAX_HOURS = 23;
|
|
|
|
static const cron_int CRON_MIN_DAYS_OF_WEEK = 1;
|
|
static const cron_int CRON_MAX_DAYS_OF_WEEK = 7;
|
|
|
|
static const cron_int CRON_MIN_DAYS_OF_MONTH = 1;
|
|
static const cron_int CRON_MAX_DAYS_OF_MONTH = 31;
|
|
|
|
static const cron_int CRON_MIN_MONTHS = 0;
|
|
static const cron_int CRON_MAX_MONTHS = 11;
|
|
|
|
static const cron_int CRON_MAX_YEARS_DIFF = 4;
|
|
|
|
#ifdef CRONCPP_IS_CPP17
|
|
static const inline std::vector<std::string> DAYS = { "NIL", "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
|
|
static const inline std::vector<std::string> MONTHS = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
|
|
#else
|
|
|
|
static std::vector<std::string>& DAYS()
|
|
{
|
|
static std::vector<std::string> days = { "NIL", "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
|
|
return days;
|
|
}
|
|
|
|
static std::vector<std::string>& MONTHS()
|
|
{
|
|
static std::vector<std::string> months = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
|
|
return months;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
struct cron_quartz_traits
|
|
{
|
|
static const cron_int CRON_MIN_SECONDS = 0;
|
|
static const cron_int CRON_MAX_SECONDS = 59;
|
|
|
|
static const cron_int CRON_MIN_MINUTES = 0;
|
|
static const cron_int CRON_MAX_MINUTES = 59;
|
|
|
|
static const cron_int CRON_MIN_HOURS = 0;
|
|
static const cron_int CRON_MAX_HOURS = 23;
|
|
|
|
static const cron_int CRON_MIN_DAYS_OF_WEEK = 1;
|
|
static const cron_int CRON_MAX_DAYS_OF_WEEK = 7;
|
|
|
|
static const cron_int CRON_MIN_DAYS_OF_MONTH = 1;
|
|
static const cron_int CRON_MAX_DAYS_OF_MONTH = 31;
|
|
|
|
static const cron_int CRON_MIN_MONTHS = 1;
|
|
static const cron_int CRON_MAX_MONTHS = 12;
|
|
|
|
static const cron_int CRON_MAX_YEARS_DIFF = 4;
|
|
|
|
#ifdef CRONCPP_IS_CPP17
|
|
static const inline std::vector<std::string> DAYS = { "NIL", "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
|
|
static const inline std::vector<std::string> MONTHS = { "NIL", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
|
|
#else
|
|
static std::vector<std::string>& DAYS()
|
|
{
|
|
static std::vector<std::string> days = { "NIL", "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
|
|
return days;
|
|
}
|
|
|
|
static std::vector<std::string>& MONTHS()
|
|
{
|
|
static std::vector<std::string> months = { "NIL", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
|
|
return months;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
class cronexpr;
|
|
|
|
template <typename Traits = cron_standard_traits>
|
|
static cronexpr make_cron(STRING_VIEW expr);
|
|
|
|
class cronexpr
|
|
{
|
|
std::bitset<60> seconds;
|
|
std::bitset<60> minutes;
|
|
std::bitset<24> hours;
|
|
std::bitset<7> days_of_week;
|
|
std::bitset<31> days_of_month;
|
|
std::bitset<12> months;
|
|
|
|
friend bool operator==(cronexpr const & e1, cronexpr const & e2);
|
|
friend bool operator!=(cronexpr const & e1, cronexpr const & e2);
|
|
|
|
template <typename Traits>
|
|
friend bool detail::find_next(cronexpr const & cex,
|
|
std::tm& date,
|
|
size_t const dot);
|
|
|
|
friend std::string to_string(cronexpr const & cex);
|
|
|
|
template <typename Traits>
|
|
friend cronexpr make_cron(STRING_VIEW expr);
|
|
};
|
|
|
|
inline bool operator==(cronexpr const & e1, cronexpr const & e2)
|
|
{
|
|
return
|
|
e1.seconds == e2.seconds &&
|
|
e1.minutes == e2.minutes &&
|
|
e1.hours == e2.hours &&
|
|
e1.days_of_week == e2.days_of_week &&
|
|
e1.days_of_month == e2.days_of_month &&
|
|
e1.months == e2.months;
|
|
}
|
|
|
|
inline bool operator!=(cronexpr const & e1, cronexpr const & e2)
|
|
{
|
|
return !(e1 == e2);
|
|
}
|
|
|
|
inline std::string to_string(cronexpr const & cex)
|
|
{
|
|
return
|
|
cex.seconds.to_string() + " " +
|
|
cex.minutes.to_string() + " " +
|
|
cex.hours.to_string() + " " +
|
|
cex.days_of_month.to_string() + " " +
|
|
cex.months.to_string() + " " +
|
|
cex.days_of_week.to_string();
|
|
}
|
|
|
|
namespace utils
|
|
{
|
|
inline std::time_t tm_to_time(std::tm& date)
|
|
{
|
|
return std::mktime(&date);
|
|
}
|
|
|
|
inline std::tm* time_to_tm(std::time_t const * date, std::tm* const out)
|
|
{
|
|
#ifdef _WIN32
|
|
errno_t err = localtime_s(out, date);
|
|
return 0 == err ? out : nullptr;
|
|
#else
|
|
return localtime_r(date, out);
|
|
#endif
|
|
}
|
|
|
|
inline std::tm to_tm(STRING_VIEW time)
|
|
{
|
|
std::istringstream str(time.data());
|
|
str.imbue(std::locale(setlocale(LC_ALL, nullptr)));
|
|
|
|
std::tm result;
|
|
str >> std::get_time(&result, "%Y-%m-%d %H:%M:%S");
|
|
if (str.fail()) throw std::runtime_error("Parsing date failed!");
|
|
|
|
result.tm_isdst = -1; // DST info not available
|
|
|
|
return result;
|
|
}
|
|
|
|
inline std::string to_string(std::tm const & tm)
|
|
{
|
|
std::ostringstream str;
|
|
str.imbue(std::locale(setlocale(LC_ALL, nullptr)));
|
|
str << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
|
|
if (str.fail()) throw std::runtime_error("Writing date failed!");
|
|
|
|
return str.str();
|
|
}
|
|
|
|
inline std::string to_upper(std::string text)
|
|
{
|
|
std::transform(std::begin(text), std::end(text),
|
|
std::begin(text), static_cast<int(*)(int)>(std::toupper));
|
|
|
|
return text;
|
|
}
|
|
|
|
static std::vector<std::string> split(STRING_VIEW text, char const delimiter)
|
|
{
|
|
std::vector<std::string> tokens;
|
|
std::string token;
|
|
std::istringstream tokenStream(text.data());
|
|
while (std::getline(tokenStream, token, delimiter))
|
|
{
|
|
tokens.push_back(token);
|
|
}
|
|
return tokens;
|
|
}
|
|
|
|
CONSTEXPTR inline bool contains(STRING_VIEW text, char const ch) noexcept
|
|
{
|
|
return STRING_VIEW_NPOS != text.find_first_of(ch);
|
|
}
|
|
}
|
|
|
|
namespace detail
|
|
{
|
|
|
|
inline cron_int to_cron_int(STRING_VIEW text)
|
|
{
|
|
try
|
|
{
|
|
return static_cast<cron_int>(Strings::ToUnsignedInt(text.data()));
|
|
}
|
|
catch (std::exception const & ex)
|
|
{
|
|
throw bad_cronexpr(ex.what());
|
|
}
|
|
}
|
|
|
|
static std::string replace_ordinals(
|
|
std::string text,
|
|
std::vector<std::string> const & replacement)
|
|
{
|
|
for (size_t i = 0; i < replacement.size(); ++i)
|
|
{
|
|
auto pos = text.find(replacement[i]);
|
|
if (std::string::npos != pos)
|
|
text.replace(pos, 3 ,std::to_string(i));
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
static std::pair<cron_int, cron_int> make_range(
|
|
STRING_VIEW field,
|
|
cron_int const minval,
|
|
cron_int const maxval)
|
|
{
|
|
cron_int first = 0;
|
|
cron_int last = 0;
|
|
if (field.size() == 1 && field[0] == '*')
|
|
{
|
|
first = minval;
|
|
last = maxval;
|
|
}
|
|
else if (!utils::contains(field, '-'))
|
|
{
|
|
first = to_cron_int(field);
|
|
last = first;
|
|
}
|
|
else
|
|
{
|
|
auto parts = utils::split(field, '-');
|
|
if (parts.size() != 2)
|
|
throw bad_cronexpr("Specified range requires two fields");
|
|
|
|
first = to_cron_int(parts[0]);
|
|
last = to_cron_int(parts[1]);
|
|
}
|
|
|
|
if (first > maxval || last > maxval)
|
|
{
|
|
throw bad_cronexpr("Specified range exceeds maximum");
|
|
}
|
|
if (first < minval || last < minval)
|
|
{
|
|
throw bad_cronexpr("Specified range is less than minimum");
|
|
}
|
|
if (first > last)
|
|
{
|
|
throw bad_cronexpr("Specified range start exceeds range end");
|
|
}
|
|
|
|
return { first, last };
|
|
}
|
|
|
|
template <size_t N>
|
|
static void set_cron_field(
|
|
STRING_VIEW value,
|
|
std::bitset<N>& target,
|
|
cron_int const minval,
|
|
cron_int const maxval)
|
|
{
|
|
if(value.length() > 0 && value[value.length()-1] == ',')
|
|
throw bad_cronexpr("Value cannot end with comma");
|
|
|
|
auto fields = utils::split(value, ',');
|
|
if (fields.empty())
|
|
throw bad_cronexpr("Expression parsing error");
|
|
|
|
for (auto const & field : fields)
|
|
{
|
|
if (!utils::contains(field, '/'))
|
|
{
|
|
#ifdef CRONCPP_IS_CPP17
|
|
auto[first, last] = detail::make_range(field, minval, maxval);
|
|
#else
|
|
auto range = detail::make_range(field, minval, maxval);
|
|
auto first = range.first;
|
|
auto last = range.second;
|
|
#endif
|
|
for (cron_int i = first - minval; i <= last - minval; ++i)
|
|
{
|
|
target.set(i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto parts = utils::split(field, '/');
|
|
if (parts.size() != 2)
|
|
throw bad_cronexpr("Incrementer must have two fields");
|
|
|
|
#ifdef CRONCPP_IS_CPP17
|
|
auto[first, last] = detail::make_range(parts[0], minval, maxval);
|
|
#else
|
|
auto range = detail::make_range(parts[0], minval, maxval);
|
|
auto first = range.first;
|
|
auto last = range.second;
|
|
#endif
|
|
|
|
if (!utils::contains(parts[0], '-'))
|
|
{
|
|
last = maxval;
|
|
}
|
|
|
|
auto delta = detail::to_cron_int(parts[1]);
|
|
if(delta <= 0)
|
|
throw bad_cronexpr("Incrementer must be a positive value");
|
|
|
|
for (cron_int i = first - minval; i <= last - minval; i += delta)
|
|
{
|
|
target.set(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename Traits>
|
|
static void set_cron_days_of_week(
|
|
std::string value,
|
|
std::bitset<7>& target)
|
|
{
|
|
auto days = utils::to_upper(value);
|
|
auto days_replaced = detail::replace_ordinals(
|
|
days,
|
|
#ifdef CRONCPP_IS_CPP17
|
|
Traits::DAYS
|
|
#else
|
|
Traits::DAYS()
|
|
#endif
|
|
);
|
|
|
|
if (days_replaced.size() == 1 && days_replaced[0] == '?')
|
|
days_replaced[0] = '*';
|
|
|
|
set_cron_field(
|
|
days_replaced,
|
|
target,
|
|
Traits::CRON_MIN_DAYS_OF_WEEK,
|
|
Traits::CRON_MAX_DAYS_OF_WEEK);
|
|
}
|
|
|
|
template <typename Traits>
|
|
static void set_cron_days_of_month(
|
|
std::string value,
|
|
std::bitset<31>& target)
|
|
{
|
|
if (value.size() == 1 && value[0] == '?')
|
|
value[0] = '*';
|
|
|
|
set_cron_field(
|
|
value,
|
|
target,
|
|
Traits::CRON_MIN_DAYS_OF_MONTH,
|
|
Traits::CRON_MAX_DAYS_OF_MONTH);
|
|
}
|
|
|
|
template <typename Traits>
|
|
static void set_cron_month(
|
|
std::string value,
|
|
std::bitset<12>& target)
|
|
{
|
|
auto month = utils::to_upper(value);
|
|
auto month_replaced = replace_ordinals(
|
|
month,
|
|
#ifdef CRONCPP_IS_CPP17
|
|
Traits::MONTHS
|
|
#else
|
|
Traits::MONTHS()
|
|
#endif
|
|
);
|
|
|
|
set_cron_field(
|
|
month_replaced,
|
|
target,
|
|
Traits::CRON_MIN_MONTHS,
|
|
Traits::CRON_MAX_MONTHS);
|
|
}
|
|
|
|
template <size_t N>
|
|
inline size_t next_set_bit(
|
|
std::bitset<N> const & target,
|
|
size_t /*minimum*/,
|
|
size_t /*maximum*/,
|
|
size_t offset)
|
|
{
|
|
for (auto i = offset; i < N; ++i)
|
|
{
|
|
if (target.test(i)) return i;
|
|
}
|
|
|
|
return INVALID_CRON_INDEX;
|
|
}
|
|
|
|
inline void add_to_field(
|
|
std::tm& date,
|
|
cron_field const field,
|
|
int const val)
|
|
{
|
|
switch (field)
|
|
{
|
|
case cron_field::second:
|
|
date.tm_sec += val;
|
|
break;
|
|
case cron_field::minute:
|
|
date.tm_min += val;
|
|
break;
|
|
case cron_field::hour_of_day:
|
|
date.tm_hour += val;
|
|
break;
|
|
case cron_field::day_of_week:
|
|
case cron_field::day_of_month:
|
|
date.tm_mday += val;
|
|
break;
|
|
case cron_field::month:
|
|
date.tm_mon += val;
|
|
break;
|
|
case cron_field::year:
|
|
date.tm_year += val;
|
|
break;
|
|
}
|
|
|
|
if (INVALID_TIME == utils::tm_to_time(date))
|
|
throw bad_cronexpr("Invalid time expression");
|
|
}
|
|
|
|
inline void set_field(
|
|
std::tm& date,
|
|
cron_field const field,
|
|
int const val)
|
|
{
|
|
switch (field)
|
|
{
|
|
case cron_field::second:
|
|
date.tm_sec = val;
|
|
break;
|
|
case cron_field::minute:
|
|
date.tm_min = val;
|
|
break;
|
|
case cron_field::hour_of_day:
|
|
date.tm_hour = val;
|
|
break;
|
|
case cron_field::day_of_week:
|
|
date.tm_wday = val;
|
|
break;
|
|
case cron_field::day_of_month:
|
|
date.tm_mday = val;
|
|
break;
|
|
case cron_field::month:
|
|
date.tm_mon = val;
|
|
break;
|
|
case cron_field::year:
|
|
date.tm_year = val;
|
|
break;
|
|
}
|
|
|
|
if (INVALID_TIME == utils::tm_to_time(date))
|
|
throw bad_cronexpr("Invalid time expression");
|
|
}
|
|
|
|
inline void reset_field(
|
|
std::tm& date,
|
|
cron_field const field)
|
|
{
|
|
switch (field)
|
|
{
|
|
case cron_field::second:
|
|
date.tm_sec = 0;
|
|
break;
|
|
case cron_field::minute:
|
|
date.tm_min = 0;
|
|
break;
|
|
case cron_field::hour_of_day:
|
|
date.tm_hour = 0;
|
|
break;
|
|
case cron_field::day_of_week:
|
|
date.tm_wday = 0;
|
|
break;
|
|
case cron_field::day_of_month:
|
|
date.tm_mday = 1;
|
|
break;
|
|
case cron_field::month:
|
|
date.tm_mon = 0;
|
|
break;
|
|
case cron_field::year:
|
|
date.tm_year = 0;
|
|
break;
|
|
}
|
|
|
|
if (INVALID_TIME == utils::tm_to_time(date))
|
|
throw bad_cronexpr("Invalid time expression");
|
|
}
|
|
|
|
inline void reset_all_fields(
|
|
std::tm& date,
|
|
std::bitset<7> const & marked_fields)
|
|
{
|
|
for (size_t i = 0; i < marked_fields.size(); ++i)
|
|
{
|
|
if (marked_fields.test(i))
|
|
reset_field(date, static_cast<cron_field>(i));
|
|
}
|
|
}
|
|
|
|
inline void mark_field(
|
|
std::bitset<7> & orders,
|
|
cron_field const field)
|
|
{
|
|
if (!orders.test(static_cast<size_t>(field)))
|
|
orders.set(static_cast<size_t>(field));
|
|
}
|
|
|
|
template <size_t N>
|
|
static size_t find_next(
|
|
std::bitset<N> const & target,
|
|
std::tm& date,
|
|
unsigned int const minimum,
|
|
unsigned int const maximum,
|
|
unsigned int const value,
|
|
cron_field const field,
|
|
cron_field const next_field,
|
|
std::bitset<7> const & marked_fields)
|
|
{
|
|
auto next_value = next_set_bit(target, minimum, maximum, value);
|
|
if (INVALID_CRON_INDEX == next_value)
|
|
{
|
|
add_to_field(date, next_field, 1);
|
|
reset_field(date, field);
|
|
next_value = next_set_bit(target, minimum, maximum, 0);
|
|
}
|
|
|
|
if (INVALID_CRON_INDEX == next_value || next_value != value)
|
|
{
|
|
set_field(date, field, static_cast<int>(next_value));
|
|
reset_all_fields(date, marked_fields);
|
|
}
|
|
|
|
return next_value;
|
|
}
|
|
|
|
template <typename Traits>
|
|
static size_t find_next_day(
|
|
std::tm& date,
|
|
std::bitset<31> const & days_of_month,
|
|
size_t day_of_month,
|
|
std::bitset<7> const & days_of_week,
|
|
size_t day_of_week,
|
|
std::bitset<7> const & marked_fields)
|
|
{
|
|
unsigned int count = 0;
|
|
unsigned int maximum = 366;
|
|
while (
|
|
(!days_of_month.test(day_of_month - Traits::CRON_MIN_DAYS_OF_MONTH) ||
|
|
!days_of_week.test(day_of_week - Traits::CRON_MIN_DAYS_OF_WEEK))
|
|
&& count++ < maximum)
|
|
{
|
|
add_to_field(date, cron_field::day_of_month, 1);
|
|
|
|
day_of_month = date.tm_mday;
|
|
day_of_week = date.tm_wday;
|
|
|
|
reset_all_fields(date, marked_fields);
|
|
}
|
|
|
|
return day_of_month;
|
|
}
|
|
|
|
template <typename Traits>
|
|
static bool find_next(cronexpr const & cex,
|
|
std::tm& date,
|
|
size_t const dot)
|
|
{
|
|
bool res = true;
|
|
|
|
std::bitset<7> marked_fields{ 0 };
|
|
std::bitset<7> empty_list{ 0 };
|
|
|
|
unsigned int second = date.tm_sec;
|
|
auto updated_second = find_next(
|
|
cex.seconds,
|
|
date,
|
|
Traits::CRON_MIN_SECONDS,
|
|
Traits::CRON_MAX_SECONDS,
|
|
second,
|
|
cron_field::second,
|
|
cron_field::minute,
|
|
empty_list);
|
|
|
|
if (second == updated_second)
|
|
{
|
|
mark_field(marked_fields, cron_field::second);
|
|
}
|
|
|
|
unsigned int minute = date.tm_min;
|
|
auto update_minute = find_next(
|
|
cex.minutes,
|
|
date,
|
|
Traits::CRON_MIN_MINUTES,
|
|
Traits::CRON_MAX_MINUTES,
|
|
minute,
|
|
cron_field::minute,
|
|
cron_field::hour_of_day,
|
|
marked_fields);
|
|
if (minute == update_minute)
|
|
{
|
|
mark_field(marked_fields, cron_field::minute);
|
|
}
|
|
else
|
|
{
|
|
res = find_next<Traits>(cex, date, dot);
|
|
if (!res) return res;
|
|
}
|
|
|
|
unsigned int hour = date.tm_hour;
|
|
auto updated_hour = find_next(
|
|
cex.hours,
|
|
date,
|
|
Traits::CRON_MIN_HOURS,
|
|
Traits::CRON_MAX_HOURS,
|
|
hour,
|
|
cron_field::hour_of_day,
|
|
cron_field::day_of_week,
|
|
marked_fields);
|
|
if (hour == updated_hour)
|
|
{
|
|
mark_field(marked_fields, cron_field::hour_of_day);
|
|
}
|
|
else
|
|
{
|
|
res = find_next<Traits>(cex, date, dot);
|
|
if (!res) return res;
|
|
}
|
|
|
|
unsigned int day_of_week = date.tm_wday;
|
|
unsigned int day_of_month = date.tm_mday;
|
|
auto updated_day_of_month = find_next_day<Traits>(
|
|
date,
|
|
cex.days_of_month,
|
|
day_of_month,
|
|
cex.days_of_week,
|
|
day_of_week,
|
|
marked_fields);
|
|
if (day_of_month == updated_day_of_month)
|
|
{
|
|
mark_field(marked_fields, cron_field::day_of_month);
|
|
}
|
|
else
|
|
{
|
|
res = find_next<Traits>(cex, date, dot);
|
|
if (!res) return res;
|
|
}
|
|
|
|
unsigned int month = date.tm_mon;
|
|
auto updated_month = find_next(
|
|
cex.months,
|
|
date,
|
|
Traits::CRON_MIN_MONTHS,
|
|
Traits::CRON_MAX_MONTHS,
|
|
month,
|
|
cron_field::month,
|
|
cron_field::year,
|
|
marked_fields);
|
|
if (month != updated_month)
|
|
{
|
|
if (date.tm_year - dot > Traits::CRON_MAX_YEARS_DIFF)
|
|
return false;
|
|
|
|
res = find_next<Traits>(cex, date, dot);
|
|
if (!res) return res;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
}
|
|
|
|
template <typename Traits>
|
|
static cronexpr make_cron(STRING_VIEW expr)
|
|
{
|
|
cronexpr cex;
|
|
|
|
if (expr.empty())
|
|
throw bad_cronexpr("Invalid empty cron expression");
|
|
|
|
auto fields = utils::split(expr, ' ');
|
|
fields.erase(
|
|
std::remove_if(std::begin(fields), std::end(fields),
|
|
[](STRING_VIEW s) {return s.empty(); }),
|
|
std::end(fields));
|
|
if (fields.size() != 6)
|
|
throw bad_cronexpr("cron expression must have six fields");
|
|
|
|
detail::set_cron_field(fields[0], cex.seconds, Traits::CRON_MIN_SECONDS, Traits::CRON_MAX_SECONDS);
|
|
detail::set_cron_field(fields[1], cex.minutes, Traits::CRON_MIN_MINUTES, Traits::CRON_MAX_MINUTES);
|
|
detail::set_cron_field(fields[2], cex.hours, Traits::CRON_MIN_HOURS, Traits::CRON_MAX_HOURS);
|
|
|
|
detail::set_cron_days_of_week<Traits>(fields[5], cex.days_of_week);
|
|
|
|
detail::set_cron_days_of_month<Traits>(fields[3], cex.days_of_month);
|
|
|
|
detail::set_cron_month<Traits>(fields[4], cex.months);
|
|
|
|
return cex;
|
|
}
|
|
|
|
template <typename Traits = cron_standard_traits>
|
|
static std::tm cron_next(cronexpr const & cex, std::tm date)
|
|
{
|
|
time_t original = utils::tm_to_time(date);
|
|
if (INVALID_TIME == original) return {};
|
|
|
|
if (!detail::find_next<Traits>(cex, date, date.tm_year))
|
|
return {};
|
|
|
|
time_t calculated = utils::tm_to_time(date);
|
|
if (INVALID_TIME == calculated) return {};
|
|
|
|
if (calculated == original)
|
|
{
|
|
add_to_field(date, detail::cron_field::second, 1);
|
|
if (!detail::find_next<Traits>(cex, date, date.tm_year))
|
|
return {};
|
|
}
|
|
|
|
return date;
|
|
}
|
|
|
|
template <typename Traits = cron_standard_traits>
|
|
static std::time_t cron_next(cronexpr const & cex, std::time_t const & date)
|
|
{
|
|
std::tm val;
|
|
std::tm* dt = utils::time_to_tm(&date, &val);
|
|
if (dt == nullptr) return INVALID_TIME;
|
|
|
|
time_t original = utils::tm_to_time(*dt);
|
|
if (INVALID_TIME == original) return INVALID_TIME;
|
|
|
|
if(!detail::find_next<Traits>(cex, *dt, dt->tm_year))
|
|
return INVALID_TIME;
|
|
|
|
time_t calculated = utils::tm_to_time(*dt);
|
|
if (INVALID_TIME == calculated) return calculated;
|
|
|
|
if (calculated == original)
|
|
{
|
|
add_to_field(*dt, detail::cron_field::second, 1);
|
|
if(!detail::find_next<Traits>(cex, *dt, dt->tm_year))
|
|
return INVALID_TIME;
|
|
}
|
|
|
|
return utils::tm_to_time(*dt);
|
|
}
|
|
}
|