DateTimeParser Class Reference

#include <DateTimeParser.h>

Collaboration diagram for DateTimeParser:

Classes
struct	DateTime

Public Types
enum	FormatType { FormatType::Date, FormatType::Time, FormatType::Timezone }

Public Member Functions
std::optional< int64_t >	parse (std::string_view const, unsigned dim)
void	setFormatType (FormatType)
std::string_view	unparsed () const

Private Member Functions
bool	parseWithFormat (std::string_view format, std::string_view &str)
void	resetDateTime ()
bool	updateDateTimeAndStr (char const field, std::string_view &)

Private Attributes
DateTime	dt_
FormatType	format_type_
std::string_view	unparsed_

Detailed Description

Set format_type_ and parse date/time/timestamp strings into (s,ms,us,ns) since the epoch based on given dim in (0,3,6,9) respectively. Basic idea is to parse given string by matching to formats ("%Y-%m-%d", "%m/%d/%Y", ...) until a valid parse is found. Save parsed values into a DateTime dt_ struct from which the final epoch-based int64_t value is calculated.

Definition at line 55 of file DateTimeParser.h.

Member Enumeration Documentation

enum DateTimeParser::FormatType

strong

Enumerator
Date
Time
Timezone

Definition at line 57 of file DateTimeParser.h.

{ Date, Time, Timezone };

Member Function Documentation

std::optional< int64_t > DateTimeParser::parse	(	std::string_view const	str,
		unsigned	dim
	)

Definition at line 244 of file DateTimeParser.cpp.

References dt_, format_type_, anonymous_namespace{DateTimeParser.cpp}::formatViews(), DateTimeParser::DateTime::getTime(), parseWithFormat(), and unparsed_.

Referenced by dateTimeParseOptional< kDATE >(), dateTimeParseOptional< kTIME >(), and dateTimeParseOptional< kTIMESTAMP >().

                                                                                 {
  static std::vector<std::vector<std::string_view>> const& format_views = formatViews();
  auto const& formats = format_views.at(static_cast<int>(format_type_));
  for (std::string_view const format : formats) {
    std::string_view str_unparsed = str;
    if (parseWithFormat(format, str_unparsed)) {
      unparsed_ = str_unparsed;
      return dt_.getTime(dim);
    }
  }
  unparsed_ = str;
  return std::nullopt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DateTimeParser::parseWithFormat ( std::string_view  format, std::string_view &  str  )

private

Definition at line 219 of file DateTimeParser.cpp.

References anonymous_namespace{DateTimeParser.cpp}::eatSpace(), and updateDateTimeAndStr().

Referenced by parse().

                                                                               {
  while (!format.empty()) {
    if (format.front() == '%') {
      eatSpace(str);
      if (!updateDateTimeAndStr(format[1], str)) {
        return false;
      }
      format.remove_prefix(2);
    } else if (isspace(format.front())) {
      eatSpace(format);
      eatSpace(str);
    } else if (!str.empty() && format.front() == str.front()) {
      format.remove_prefix(1);
      str.remove_prefix(1);
    } else {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DateTimeParser::resetDateTime ( )

private

Definition at line 258 of file DateTimeParser.cpp.

References dt_.

Referenced by setFormatType().

                                   {
  dt_ = DateTime();
}

Here is the caller graph for this function:

void DateTimeParser::setFormatType

(

FormatType

format_type

)

Definition at line 262 of file DateTimeParser.cpp.

References format_type_, and resetDateTime().

Referenced by dateTimeParseOptional< kDATE >(), dateTimeParseOptional< kTIME >(), and dateTimeParseOptional< kTIMESTAMP >().

                                                         {
  resetDateTime();
  format_type_ = format_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string_view DateTimeParser::unparsed

(

)

const

Definition at line 267 of file DateTimeParser.cpp.

References unparsed_.

Referenced by dateTimeParseOptional< kDATE >(), dateTimeParseOptional< kTIME >(), and dateTimeParseOptional< kTIMESTAMP >().

                                              {
  return unparsed_;
}

Here is the caller graph for this function:

bool DateTimeParser::updateDateTimeAndStr ( char const  field, std::string_view &  str  )

private

Definition at line 273 of file DateTimeParser.cpp.

References cat(), DateTimeParser::DateTime::d, dt_, anonymous_namespace{DateTimeParser.cpp}::eatMonth(), DateTimeParser::DateTime::H, DateTimeParser::DateTime::m, DateTimeParser::DateTime::M, anonymous_namespace{DateTimeParser.cpp}::month_prefixes, DateTimeParser::DateTime::n, DateTimeParser::DateTime::p, anonymous_namespace{DateTimeParser.cpp}::pow_10, DateTimeParser::DateTime::S, DateTimeParser::DateTime::Y, and DateTimeParser::DateTime::z.

Referenced by parseWithFormat().

                                                                               {
  switch (field) {
    case 'Y':
      if (auto const year = fromChars<int64_t>(str)) {
        dt_.Y = *year;
        return true;
      }
      return false;
    case 'y':
      // %y matches 1 or 2 digits. If 3 or more digits are provided,
      // then it is considered an unsuccessful parse.
      if (auto const year = fromChars<unsigned>(str)) {
        if (*year < 69) {
          dt_.Y = 2000 + *year;
          return true;
        } else if (*year < 100) {
          dt_.Y = 1900 + *year;
          return true;
        }
      }
      return false;
    case 'm':
      if (auto const month = fromChars<unsigned>(str, 2)) {
        if (1 <= *month && *month <= 12) {
          dt_.m = *month;
          return true;
        }
      }
      return false;
    case 'b':
      if (3 <= str.size()) {
        int const key =
            std::tolower(str[0]) << 16 | std::tolower(str[1]) << 8 | std::tolower(str[2]);
        constexpr auto end = month_prefixes.data() + month_prefixes.size();
        // This is faster than a lookup into a std::unordered_map.
        auto const ptr = std::find(month_prefixes.data(), end, key);
        if (ptr != end) {
          dt_.m = ptr - month_prefixes.data() + 1;
          eatMonth(dt_.m, str);
          return true;
        }
      }
      return false;
    case 'd':
      if (auto const day = fromChars<unsigned>(str, 2)) {
        if (1 <= *day && *day <= 31) {
          dt_.d = *day;
          return true;
        }
      }
      return false;
    case 'H':
      if (auto const hour = fromChars<unsigned>(str, 2)) {
        if (*hour <= 23) {
          dt_.H = *hour;
          return true;
        }
      }
      return false;
    case 'I':
      if (auto const hour = fromChars<unsigned>(str, 2)) {
        if (1 <= *hour && *hour <= 12) {
          dt_.H = *hour;
          return true;
        }
      }
      return false;
    case 'M':
      if (auto const minute = fromChars<unsigned>(str, 2)) {
        if (*minute <= 59) {
          dt_.M = *minute;
          return true;
        }
      }
      return false;
    case 'S':
      if (auto const second = fromChars<unsigned>(str, 2)) {
        if (*second <= 61) {
          dt_.S = *second;
          if (!str.empty() && str.front() == '.') {
            str.remove_prefix(1);
            size_t len = str.size();
            if (auto const ns = fromChars<unsigned>(str, 9)) {
              len -= str.size();
              dt_.n = *ns * pow_10[9 - len];
            } else {
              return false;  // Reject period not followed by a digit
            }
          }
          return true;
        }
      }
      return false;
    case 'z':
      // [-+]\d\d:?\d\d
      if (5 <= str.size() && (str.front() == '-' || str.front() == '+') &&
          isdigit(str[1]) && isdigit(str[2]) && isdigit(str[4]) &&
          (str[3] == ':' ? 6 <= str.size() && isdigit(str[5]) : isdigit(str[3]))) {
        char const* sep = &str[3];
        int hours{0}, minutes{0};
        std::from_chars(str.data() + 1, sep, hours);
        sep += *sep == ':';
        std::from_chars(sep, sep + 2, minutes);
        dt_.z = (str.front() == '-' ? -60 : 60) * (60 * hours + minutes);
        str.remove_prefix(sep - str.data() + 2);
        return true;
      }
      return false;
    case 'p':
      // %p implies optional, so never return false
      if (boost::algorithm::istarts_with(str, "am") ||
          boost::algorithm::istarts_with(str, "pm") ||
          boost::algorithm::istarts_with(str, "a.m.") ||
          boost::algorithm::istarts_with(str, "p.m.")) {
        dt_.p = std::tolower(str.front()) == 'p';
        str.remove_prefix(std::tolower(str[1]) == 'm' ? 2 : 4);
      } else {
        dt_.p.reset();
      }
      return true;
    default:
      throw std::runtime_error(cat("Unrecognized format: %", field));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

DateTime DateTimeParser::dt_

private

Definition at line 78 of file DateTimeParser.h.

Referenced by parse(), resetDateTime(), and updateDateTimeAndStr().

FormatType DateTimeParser::format_type_

private

Definition at line 79 of file DateTimeParser.h.

Referenced by parse(), and setFormatType().

std::string_view DateTimeParser::unparsed_

private

Definition at line 80 of file DateTimeParser.h.

Referenced by parse(), and unparsed().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Shared/DateTimeParser.h
• /home/jenkins-slave/workspace/core-os-doxygen/Shared/DateTimeParser.cpp