feat(reflect-cpp): Switched from glaze -> reflect cpp

A bug was discovered in glaze which prevented valid toml output. We have
switched to toml++ and reflect-cpp. The interface has remained the same
so this should not break any code

build-config/reflect-cpp/include/rfl/Timestamp.hpp

@@ -0,0 +1,121 @@
+#ifndef RFL_TIMESTAMP_HPP_
+#define RFL_TIMESTAMP_HPP_
+
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+#include "Literal.hpp"
+#include "Result.hpp"
+#include "internal/StringLiteral.hpp"
+
+namespace rfl {
+
+/// For serializing and deserializing time stamps.
+template <internal::StringLiteral _format>
+class Timestamp {
+  constexpr static const internal::StringLiteral format_ = _format;
+
+ public:
+  using Format = rfl::Literal<_format>;
+
+  using ReflectionType = std::string;
+
+  Timestamp() : tm_(std::tm{}) {}
+
+  Timestamp(const char* _str) : tm_(std::tm{}) {
+    const auto r = strptime(_str, _format.str().c_str(), &tm_);
+    if (r == NULL) {
+      throw std::runtime_error("String '" + std::string(_str) +
+                               "' did not match format '" + Format().str() +
+                               "'.");
+    }
+  }
+
+  Timestamp(const std::string& _str) : Timestamp(_str.c_str()) {}
+
+  Timestamp(const std::tm& _tm) : tm_(_tm) {}
+
+  Timestamp(const time_t _t) : tm_(std::tm{}) {
+    auto t = _t;
+#if defined(_MSC_VER) || defined(__MINGW32__)
+    gmtime_s(&tm_, &t);
+#else
+    gmtime_r(&t, &tm_);
+#endif
+  }
+
+  ~Timestamp() = default;
+
+  /// Returns a result containing the timestamp when successful or an Error
+  /// otherwise.
+  static Result<Timestamp> from_string(const char* _str) noexcept {
+    try {
+      return Timestamp(_str);
+    } catch (std::exception& e) {
+      return error(e.what());
+    }
+  }
+
+  /// Returns a result containing the timestamp when successful or an Error
+  /// otherwise.
+  static Result<Timestamp> from_string(const std::string& _str) {
+    return from_string(_str.c_str());
+  }
+
+  /// Returns a result containing the timestamp when successful or an Error
+  /// otherwise.
+  static Result<Timestamp> make(const auto& _str) noexcept {
+    return from_string(_str);
+  }
+
+  /// Necessary for the serialization to work.
+  ReflectionType reflection() const {
+    char outstr[200];
+    strftime(outstr, 200, format_.str().c_str(), &tm_);
+    return std::string(outstr);
+  }
+
+  /// Expresses the underlying timestamp as a string.
+  std::string str() const { return reflection(); }
+
+  /// Trivial accessor to the underlying time stamp.
+  std::tm& tm() { return tm_; }
+
+  /// Trivial (const) accessor to the underlying time stamp.
+  const std::tm& tm() const { return tm_; }
+
+  /// Returns a UTC time represented by a time_t type.
+  time_t to_time_t() const {
+    auto tm = tm_;
+#if defined(_MSC_VER) || defined(__MINGW32__)
+    return _mkgmtime(&tm);
+#else
+    return static_cast<time_t>(timegm(&tm) - tm_.tm_gmtoff);
+#endif
+  }
+
+ private:
+#if defined(_MSC_VER) || defined(__MINGW32__)
+  // This workaround is necessary, because strptime is not available on Windows.
+  char* strptime(const char* _s, const char* _f, std::tm* _tm) {
+    std::istringstream input(_s);
+    input.imbue(std::locale(setlocale(LC_ALL, nullptr)));
+    input >> std::get_time(_tm, _f);
+    if (input.fail()) {
+      return NULL;
+    }
+    return (char*)(_s + input.tellg());
+  }
+#endif
+
+ private:
+  /// The underlying time stamp.
+  std::tm tm_;
+};
+
+}  // namespace rfl
+
+#endif