crontab.h

#pragma once

// reference from https://github.com/mariusbancila/croncpp v2023.03.30

#include <algorithm>
#include <bitset>
#include <cctype>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>

#define crontab_cpluscplus __cplusplus
#if defined(_MSVC_LANG) && !defined(__clang__)
#define crontab_cpluscplus (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
#endif

#if crontab_cpluscplus > 201402L
#include <string_view>
#define CRONCPP_IS_CPP17
#endif

namespace util::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);
}  // namespace detail

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_s(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 utils

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;
}
}  // namespace detail

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)));
}
}  // namespace util::cron