Fix handlig of leap years in C++ (#452)

We remove the dependency on BigInt library in C++ as it suffices to crop
a year at the last four digits to determine whether it is a leap year or
not. This is much faster and needs much less maintenance.

Author: mristin

aas_core_codegen/cpp/verification/_generate.py

@@ -3270,7 +3270,6 @@ def generate_implementation(
         cpp_common.WARNING,
         Stripped(
             f"""\
-#include "./BigInt.hpp"
 #include "{include_prefix_path}/common.hpp"
 #include "{include_prefix_path}/constants.hpp"
 #include "{include_prefix_path}/verification.hpp"

test_data/cpp/test_main/aas_core_meta.v3/expected_output/verification.cpp

@@ -1,7 +1,6 @@
 // This code has been automatically generated by aas-core-codegen.
 // Do NOT edit or append.
 
-#include "./BigInt.hpp"
 #include "aas_core/aas_3_0/common.hpp"
 #include "aas_core/aas_3_0/constants.hpp"
 #include "aas_core/aas_3_0/verification.hpp"
@@ -225,74 +224,44 @@ const std::wregex kRegexDatePrefix(
   L"^(-?[0-9]+)-(0[1-9]|1[0-2])-(0[0-9]|1[0-9]|2[0-9]|30|31)"
 );
 
-template<
-  typename T,
-  std::enable_if<
-    std::is_integral<T>::value
-    || std::is_same<T, BigInt>::value
-  >* = nullptr
->
-bool IsLeapYear(T year) {
-  // NOTE (mristin):
-  // We consider the years B.C. to be one-off.
-  // See the note at: https://www.w3.org/TR/xmlschema-2/#dateTime:
-  // "'-0001' is the lexical representation of the year 1 Before Common Era
-  // (1 BCE, sometimes written "1 BC")."
-  //
-  // Hence, -1 year in XML is 1 BCE, which is 0 year in astronomical years.
-  if (year < 0) {
-    year = -year - 1;
-  }
-
-  // See: See: https://en.wikipedia.org/wiki/Leap_year#Algorithm
-  if (year % 4 > 0)
-  {
-    return false;
-  }
-
-  if (year % 100 > 0)
-  {
-    return true;
-  }
-
-  if (year % 400 > 0)
-  {
-    return false;
+/**
+ * Determine the sign of the given year as text.
+ *
+ * @param year_str year as text
+ * @return -1, 0 or 1; -1 means BC, 1 means AD. 0 means a zero year,
+ * even if specified as -0.
+ */
+int DetermineEra(const std::wstring& year_str) {
+  #ifdef DEBUG
+  if (year_str.empty()) {
+    throw std::invalid_argument(
+      "Expected a valid year string, but got an empty string"
+    );
   }
+  #endif
 
-  return true;
-}
-
+  const int sign = (year_str[0] == L'-') ? -1 : 1;
 
-bool IsLeapYear(long long year) {
-  // NOTE (mristin):
-  // We consider the years B.C. to be one-off.
-  // See the note at: https://www.w3.org/TR/xmlschema-2/#dateTime:
-  // "'-0001' is the lexical representation of the year 1 Before Common Era
-  // (1 BCE, sometimes written "1 BC")."
-  //
-  // Hence, -1 year in XML is 1 BCE, which is 0 year in astronomical years.
-  if (year < 0) {
-    year = -year - 1;
-  }
-
-  // See: See: https://en.wikipedia.org/wiki/Leap_year#Algorithm
-  if (year % 4 > 0)
-  {
-    return false;
+  size_t cursor = 0;
+  if (sign < 0) {
+    // NOTE (mristin):
+    // We skip the minus sign as prefix, including the edge case "-0".
+    ++cursor;
   }
 
-  if (year % 100 > 0)
-  {
-    return true;
+  bool is_zero = true;
+  for (; cursor < year_str.size(); ++cursor) {
+    if (year_str[cursor] != L'0') {
+      is_zero = false;
+      break;
+    }
   }
 
-  if (year % 400 > 0)
-  {
-    return false;
+  if (is_zero) {
+    return 0;
   }
 
-  return true;
+  return sign;
 }
 
 const std::map<int, int> kDaysInMonth = {
@@ -340,41 +309,62 @@ bool IsXsDateWithoutOffset(const std::wstring& text) {
   // difficult. Hence, we sacrifice the efficiency a bit for the clearer code & code
   // generation.
 
-  bool is_zero_year;
-  bool is_leap_year;
-
-  try {
-	const long long year = std::stoll(match[1].str());
-
-    is_zero_year = year == 0;
-    is_leap_year = IsLeapYear<long long>(year);
-  } catch (const std::invalid_argument&) {
-    std::wstringstream wss;
-    wss
-      << "The year matched the regex, but could not be parsed as integer: "
-      << match[1].str();
+  // NOTE (mristin):
+  // The year can be arbitrarily large in `xs:date` and `xs:dateTime`. Instead of
+  // using a BigInt implementation -- and having to maintain another dependency --
+  // we simply clip the year to the last four relevant digits for the computation of
+  // leap years.
 
-    throw std::logic_error(
-      common::WstringToUtf8(wss.str())
-    );
-  } catch (const std::out_of_range&) {
-	const BigInt year(
-      common::WstringToUtf8(match[1].str())
-    );
-    is_zero_year = year == 0;
-    is_leap_year = IsLeapYear<BigInt>(std::move(year));
-  }
+  const std::wstring year_str = match[1].str();
 
-  const int month = std::stoi(match[2].str());
-  const int day = std::stoi(match[3].str());
+  const int era = DetermineEra(year_str);
 
   // NOTE (mristin):
   // We do not accept year zero, see the note at:
   // https://www.w3.org/TR/xmlschema-2/#dateTime
-  if (is_zero_year) {
+  if (era == 0) {
     return false;
   }
 
+  std::wstring last_four_year_digits;
+
+  const size_t year_start = (era < 0) ? 1 : 0;
+  const size_t end = year_str.size();
+  size_t start = end - 4;
+  if (start < year_start) {
+    start = year_start;
+  }
+
+  const std::wstring at_most_last_four_year_digits(
+    year_str.substr(start, 4)
+  );
+
+  int year_suffix = era * std::stoi(at_most_last_four_year_digits);
+
+  // NOTE (mristin):
+  // We consider the years B.C. to be one-off.
+  // See the note at: https://www.w3.org/TR/xmlschema-2/#dateTime:
+  // "'-0001' is the lexical representation of the year 1 Before Common Era
+  // (1 BCE, sometimes written "1 BC")."
+  //
+  // Hence, -1 year in XML is 1 BCE, which is 0 year in astronomical years.
+  if (year_suffix < 0) {
+    year_suffix = -year_suffix - 1;
+  }
+
+  bool is_leap_year = true;
+
+  if (year_suffix % 4 > 0) {
+    is_leap_year = false;
+  } else if (year_suffix % 100 > 0) {
+    is_leap_year = true;
+  } else if (year_suffix % 400 > 0) {
+    is_leap_year = false;
+  }
+
+  const int month = std::stoi(match[2].str());
+  const int day = std::stoi(match[3].str());
+
   if (day <= 0) {
     return false;
   }