Lenheart
/
DP_S
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1111

This commit is contained in:
lenheart 2024-10-10 12:25:42 +08:00
parent 8089cd55a6
commit a328740e19
6 changed files with 950 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
build/.cmake/api/v1/reply/index-2024-10-07T14-59-44-0274.json → build/.cmake/api/v1/reply/index-2024-10-10T04-25-39-0638.json
View File

BIN
build/.ninja_deps
View File

Binary file not shown.

8
build/.ninja_log
View File

@ -1,5 +1,5 @@
# ninja log v5
5363 7796 1727852660065694627 src/CMakeFiles/hook_aurora.dir/controller.cpp.o 966257e703ebe5d2
2 1093 1728461142945277353 src/CMakeFiles/hook_aurora.dir/controller.cpp.o 966257e703ebe5d2
2227 2560 1727852654829719813 src/CMakeFiles/hook_aurora.dir/asmjit/core/formatter.cpp.o 7cb35bc59cbdde75
6317 6930 1727852659199698793 src/CMakeFiles/hook_aurora.dir/CConnectPool.cpp.o 2bcc4261bb94fd93
1374 1663 1727852653933724122 src/CMakeFiles/hook_aurora.dir/asmjit/core/codewriter.cpp.o b283036a98086298
@ -40,7 +40,7 @@
5005 5363 1727852657632706330 src/CMakeFiles/hook_aurora.dir/asmjit/x86/x86operand.cpp.o 74ddbb8d45ca16c4
2573 2919 1727852655189718081 src/CMakeFiles/hook_aurora.dir/asmjit/core/osutils.cpp.o 3db86a7568c27d81
2679 3408 1727852655677715734 src/CMakeFiles/hook_aurora.dir/asmjit/core/ralocal.cpp.o f40edb1c31f8debd
6264 17009 1727852669275650326 src/CMakeFiles/hook_aurora.dir/l_squirrel.cpp.o b8b3a4fd39762d4d
2 9965 1728462975023042472 src/CMakeFiles/hook_aurora.dir/l_squirrel.cpp.o b8b3a4fd39762d4d
1396 1877 1727852654146723098 src/CMakeFiles/hook_aurora.dir/asmjit/core/compiler.cpp.o 6e7de6e4d036afd9
2958 3319 1727852655589716157 src/CMakeFiles/hook_aurora.dir/asmjit/core/target.cpp.o 10d61f903e8c7da1
2261 2416 1727852654676720549 src/CMakeFiles/hook_aurora.dir/asmjit/core/globals.cpp.o d57d2e170f9bd980
@ -57,7 +57,7 @@
1866 2405 1727852654673720563 src/CMakeFiles/hook_aurora.dir/asmjit/core/emitter.cpp.o eb72cf539efd1638
2560 2895 1727852655165718196 src/CMakeFiles/hook_aurora.dir/asmjit/core/operand.cpp.o 4719abbce239cfd3
3550 3759 1727852656028714045 src/CMakeFiles/hook_aurora.dir/asmjit/core/zonetree.cpp.o 9233b9817cc604be
17010 17802 1727852670063646536 /dp_s/lib/libAurora.so f60120a0f41d47a8
9966 10705 1728462975759039236 /dp_s/lib/libAurora.so f60120a0f41d47a8
6283 14706 1727852666972661404 src/CMakeFiles/hook_aurora.dir/l_socket.cpp.o bbc2c1b1b78f6f8e
2341 2778 1727852655047718764 src/CMakeFiles/hook_aurora.dir/asmjit/core/funcargscontext.cpp.o daee57f0b878951e
2 369 1727852652638730351 src/CMakeFiles/hook_aurora.dir/asmjit/arm/a64builder.cpp.o 35230f29868e4324
@ -65,5 +65,3 @@
4927 5655 1727852657922704935 src/CMakeFiles/hook_aurora.dir/asmjit/x86/x86instapi.cpp.o b8ee5965066143b1
5731 6317 1727852658570701818 src/CMakeFiles/hook_aurora.dir/Tool.cpp.o ff4157d87b4d223d
2895 3304 1727852655574716229 src/CMakeFiles/hook_aurora.dir/asmjit/core/string.cpp.o d744bacf7efd3e43
3 960 1728318477365295769 src/CMakeFiles/hook_aurora.dir/controller.cpp.o 966257e703ebe5d2
960 1828 1728318478226291580 /dp_s/lib/libAurora.so f60120a0f41d47a8

BIN
build/src/CMakeFiles/hook_aurora.dir/l_squirrel.cpp.o
View File

Binary file not shown.

18
include/SqrReg_Game.hpp
View File

@ -7,6 +7,7 @@
#include "sqstdstring.h"
#include "sqstdsystem.h"
#include "CConnectPool.h"
#include "croncpp.h"
#include "l_socket.h"
#include <openssl/md5.h>
#include <iostream>
@ -868,10 +869,27 @@ static SQInteger AutoReload(HSQUIRRELVM v)
return 0;
}
static SQInteger L_Sq_Cron_Next(HSQUIRRELVM v)
{
const SQChar *Str;
sq_getstring(v, 2, &Str);
SQInteger Date;
sq_getinteger(v, 3, &Date);
auto cron = cron::make_cron(Str);
std::time_t next = cron::cron_next(cron, Date);
sq_pushinteger(v, next);
return 1;
}
static void RegisterGame(HSQUIRRELVM v)
{
getConfigPath(szGamePath, sizeof(szGamePath));
// 获取下一个cron
register_World_func(v, L_Sq_Cron_Next, _SC("Sq_Cron_Next"));
// int 和指针相互转换
register_World_func(v, RunScript, _SC("sq_RunScript"));

929
include/croncpp.h Normal file
View File

@ -0,0 +1,929 @@
#pragma once
#include <vector>
#include <string>
#include <sstream>
#include <bitset>
#include <cctype>
#include <ctime>
#include <iomanip>
#include <algorithm>
#include <chrono>
#if __cplusplus > 201402L
#include <string_view>
#define CRONCPP_IS_CPP17
#endif
namespace cron
{
#ifdef CRONCPP_IS_CPP17
#define CRONCPP_STRING_VIEW std::string_view
#define CRONCPP_STRING_VIEW_NPOS std::string_view::npos
#define CRONCPP_CONSTEXPTR constexpr
#else
#define CRONCPP_STRING_VIEW std::string const &
#define CRONCPP_STRING_VIEW_NPOS std::string::npos
#define CRONCPP_CONSTEXPTR
#endif
using cron_int = uint8_t;
constexpr std::time_t INVALID_TIME = static_cast<std::time_t>(-1);
constexpr size_t INVALID_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(CRONCPP_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(CRONCPP_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;
std::string expr;
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_cronstr(cronexpr const &cex);
friend std::string to_string(cronexpr const &cex);
template <typename Traits>
friend cronexpr make_cron(CRONCPP_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();
}
inline std::string to_cronstr(cronexpr const &cex)
{
return cex.expr;
}
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(CRONCPP_STRING_VIEW time)
{
std::tm result;
#if __cplusplus > 201103L
std::istringstream str(time.data());
str.imbue(std::locale(setlocale(LC_ALL, nullptr)));
str >> std::get_time(&result, "%Y-%m-%d %H:%M:%S");
if (str.fail())
throw std::runtime_error("Parsing date failed!");
#else
int year = 1900;
int month = 1;
int day = 1;
int hour = 0;
int minute = 0;
int second = 0;
sscanf(time.data(), "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second);
result.tm_year = year - 1900;
result.tm_mon = month - 1;
result.tm_mday = day;
result.tm_hour = hour;
result.tm_min = minute;
result.tm_sec = second;
#endif
result.tm_isdst = -1; // DST info not available
return result;
}
inline std::string to_string(std::tm const &tm)
{
#if __cplusplus > 201103L
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();
#else
char buff[70] = {0};
strftime(buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", &tm);
return std::string(buff);
#endif
}
inline std::string to_upper(std::string text)
{
std::transform(std::begin(text), std::end(text),
std::begin(text), [](char const c)
{ return static_cast<char>(std::toupper(c)); });
return text;
}
static std::vector<std::string> split(CRONCPP_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;
}
CRONCPP_CONSTEXPTR inline bool contains(CRONCPP_STRING_VIEW text, char const ch) noexcept
{
return CRONCPP_STRING_VIEW_NPOS != text.find_first_of(ch);
}
}
namespace detail
{
inline cron_int to_cron_int(CRONCPP_STRING_VIEW text)
{
try
{
return static_cast<cron_int>(std::stoul(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(
CRONCPP_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(
CRONCPP_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_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;
date.tm_isdst = -1;
break;
case cron_field::month:
date.tm_mon += val;
date.tm_isdst = -1;
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;
date.tm_isdst = -1;
break;
case cron_field::month:
date.tm_mon = val;
date.tm_isdst = -1;
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;
date.tm_isdst = -1;
break;
case cron_field::month:
date.tm_mon = 0;
date.tm_isdst = -1;
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_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_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(CRONCPP_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),
[](CRONCPP_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);
cex.expr = expr;
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);
}
template <typename Traits = cron_standard_traits>
static std::chrono::system_clock::time_point cron_next(cronexpr const &cex, std::chrono::system_clock::time_point const &time_point)
{
return std::chrono::system_clock::from_time_t(cron_next<Traits>(cex, std::chrono::system_clock::to_time_t(time_point)));
}
}