Merge branch 'main' into f/yas

Author: liuzicheng1987

CMakeLists.txt

@@ -439,6 +439,9 @@ if (REFLECTCPP_YAML OR REFLECTCPP_CHECK_HEADERS)
 endif ()
 
 if (REFLECTCPP_BOOST_SERIALIZATION OR REFLECTCPP_CHECK_HEADERS)
+    list(APPEND REFLECT_CPP_SOURCES
+        src/reflectcpp_boost_serialization.cpp
+    )
     if (NOT TARGET Boost::serialization)
         find_package(Boost REQUIRED COMPONENTS serialization)
     endif ()

docs/timestamps.md

@@ -1,4 +1,4 @@
-# `rfl::Timestamp` and `std::chrono::duration`
+# `rfl::Timestamp`, `std::chrono::system_clock::time_point`, and `std::chrono::duration`
 
 ## `rfl::Timestamp`
 
@@ -45,6 +45,41 @@ const rfl::Result<rfl::Timestamp<"%Y-%m-%d">> result = rfl::Timestamp<"%Y-%m-%d"
 const rfl::Result<rfl::Timestamp<"%Y-%m-%d">> error = rfl::Timestamp<"%Y-%m-%d">::from_string("not a proper time format");
 ```
 
+## `std::chrono::system_clock::time_point`
+
+`std::chrono::system_clock::time_point` is natively supported. It serializes as an ISO 8601 string with nanosecond precision:
+
+```cpp
+struct Event {
+  std::string name;
+  std::chrono::system_clock::time_point created_at;
+};
+
+rfl::json::write(Event{.name = "deploy", .created_at = std::chrono::system_clock::now()});
+```
+
+This produces:
+
+```json
+{"name":"deploy","created_at":"2024-01-15T12:00:00.123456789Z"}
+```
+
+Trailing fractional zeros are stripped, so microsecond values appear as `.123456Z` and whole seconds appear without a decimal point.
+
+On read, the following formats are accepted:
+
+- `"2024-01-15T12:00:00Z"` — UTC, no fractional seconds
+- `"2024-01-15T12:00:00.123Z"` — milliseconds
+- `"2024-01-15T12:00:00.123456Z"` — microseconds
+- `"2024-01-15T12:00:00.123456789Z"` — nanoseconds
+- `"2024-01-15T12:00:00"` — no timezone suffix (assumed UTC)
+- `"2024-01-15T10:30:00+05:30"` — timezone offset (converted to UTC)
+- `"2024-01-15T02:00:00-08:00"` — negative offset
+
+Timezone offsets are converted to UTC on read. The write path always outputs UTC with the `Z` suffix.
+
+Only `std::chrono::system_clock::time_point` is supported — other clocks like `steady_clock` do not represent calendar time and cannot be serialized as ISO 8601.
+
 ## `std::chrono::duration`
 
 `std::chrono::duration` types are serialized as an object with the count and unit as fields:

include/rfl/Commented.hpp

@@ -14,6 +14,7 @@ template <class T>
 struct Commented {
  public:
   using Type = std::remove_cvref_t<T>;
+  using ReflectionType = Type;
 
   Commented() : value_(Type()) {}
 
@@ -134,6 +135,9 @@ struct Commented {
     return *this;
   }
 
+  /// Returns the underlying object.
+  const ReflectionType& reflection() const { return value_; }
+
   /// Assigns the underlying object.
   void set(const Type& _value) { value_ = _value; }
 

include/rfl/boost_serialization/Parser.hpp

@@ -57,34 +57,6 @@ struct Parser<boost_serialization::Reader<IArchive>,
                          /*_all_required=*/true, ProcessorsType,
                          std::tuple<Ts...>> {};
 
-template <class IArchive, class OArchive, class ProcessorsType>
-  requires AreReaderAndWriter<boost_serialization::Reader<IArchive>,
-                              boost_serialization::Writer<OArchive>, Generic>
-struct Parser<boost_serialization::Reader<IArchive>,
-              boost_serialization::Writer<OArchive>, Generic, ProcessorsType> {
-  template <class T>
-  static Result<Generic> read(const boost_serialization::Reader<IArchive>&,
-                              const T&) noexcept {
-    static_assert(always_false_v<T>,
-                  "Generics are unsupported in Boost.Serialization.");
-    return error("Unsupported");
-  }
-
-  template <class P>
-  static void write(const boost_serialization::Writer<OArchive>&,
-                    const Generic&, const P&) noexcept {
-    static_assert(always_false_v<P>,
-                  "Generics are unsupported in Boost.Serialization.");
-  }
-
-  template <class T>
-  static schema::Type to_schema(T*) {
-    static_assert(always_false_v<T>,
-                  "Generics are unsupported in Boost.Serialization.");
-    return schema::Type{};
-  }
-};
-
 template <class IArchive, class OArchive, class T, bool _skip_serialization,
           bool _skip_deserialization, class ProcessorsType>
   requires AreReaderAndWriter<

include/rfl/boost_serialization/Writer.hpp

@@ -35,17 +35,17 @@ class Writer {
   ~Writer() = default;
 
   OutputArrayType array_as_root(const size_t _size) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputArrayType{};
   }
 
   OutputMapType map_as_root(const size_t _size) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputMapType{};
   }
 
   OutputObjectType object_as_root(const size_t _size) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputObjectType{};
   }
 
@@ -61,85 +61,85 @@ class Writer {
 
   OutputArrayType add_array_to_array(const size_t _size,
                                      OutputArrayType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputArrayType{};
   }
 
   OutputArrayType add_array_to_map(const std::string_view& _name,
                                    const size_t _size,
                                    OutputMapType* /*_parent*/) const {
-    *ar_ << std::string(_name);
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_key(_name);
+    write_size(_size);
     return OutputArrayType{};
   }
 
   OutputArrayType add_array_to_object(const std::string_view& /*_name*/,
                                       const size_t _size,
                                       OutputObjectType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputArrayType{};
   }
 
   OutputArrayType add_array_to_union(const size_t _index, const size_t _size,
                                      OutputUnionType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_index);
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_index(_index);
+    write_size(_size);
     return OutputArrayType{};
   }
 
   OutputMapType add_map_to_array(const size_t _size,
                                  OutputArrayType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputMapType{};
   }
 
   OutputMapType add_map_to_map(const std::string_view& _name,
                                const size_t _size,
                                OutputMapType* /*_parent*/) const {
-    *ar_ << std::string(_name);
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_key(_name);
+    write_size(_size);
     return OutputMapType{};
   }
 
   OutputMapType add_map_to_object(const std::string_view& /*_name*/,
                                   const size_t _size,
                                   OutputObjectType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputMapType{};
   }
 
   OutputMapType add_map_to_union(const size_t _index, const size_t _size,
                                  OutputUnionType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_index);
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_index(_index);
+    write_size(_size);
     return OutputMapType{};
   }
 
   OutputObjectType add_object_to_array(const size_t _size,
                                        OutputArrayType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputObjectType{};
   }
 
   OutputObjectType add_object_to_map(const std::string_view& _name,
                                      const size_t _size,
                                      OutputMapType* /*_parent*/) const {
-    *ar_ << std::string(_name);
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_key(_name);
+    write_size(_size);
     return OutputObjectType{};
   }
 
   OutputObjectType add_object_to_object(const std::string_view& /*_name*/,
                                         const size_t _size,
                                         OutputObjectType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_size(_size);
     return OutputObjectType{};
   }
 
   OutputObjectType add_object_to_union(const size_t _index, const size_t _size,
                                        OutputUnionType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_index);
-    *ar_ << static_cast<std::uint64_t>(_size);
+    write_index(_index);
+    write_size(_size);
     return OutputObjectType{};
   }
 
@@ -149,7 +149,7 @@ class Writer {
 
   OutputUnionType add_union_to_map(const std::string_view& _name,
                                    OutputMapType* /*_parent*/) const {
-    *ar_ << std::string(_name);
+    write_key(_name);
     return OutputUnionType{};
   }
 
@@ -160,7 +160,7 @@ class Writer {
 
   OutputUnionType add_union_to_union(const size_t _index,
                                      OutputUnionType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_index);
+    write_index(_index);
     return OutputUnionType{};
   }
 
@@ -174,7 +174,7 @@ class Writer {
   template <class T>
   OutputVarType add_value_to_map(const std::string_view& _name, const T& _var,
                                  OutputMapType* /*_parent*/) const {
-    *ar_ << std::string(_name);
+    write_key(_name);
     new_value(_var);
     return OutputVarType{};
   }
@@ -190,7 +190,7 @@ class Writer {
   template <class T>
   OutputVarType add_value_to_union(const size_t _index, const T& _var,
                                    OutputUnionType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_index);
+    write_index(_index);
     new_value(_var);
     return OutputVarType{};
   }
@@ -201,7 +201,7 @@ class Writer {
 
   OutputVarType add_null_to_map(const std::string_view& _name,
                                 OutputMapType* /*_parent*/) const {
-    *ar_ << std::string(_name);
+    write_key(_name);
     return OutputVarType{};
   }
 
@@ -212,7 +212,7 @@ class Writer {
 
   OutputVarType add_null_to_union(const size_t _index,
                                   OutputUnionType* /*_parent*/) const {
-    *ar_ << static_cast<std::uint64_t>(_index);
+    write_index(_index);
     return OutputVarType{};
   }
 
@@ -223,6 +223,18 @@ class Writer {
   void end_object(OutputObjectType* /*_obj*/) const {}
 
  private:
+  void write_size(const size_t _size) const {
+    *ar_ << static_cast<std::uint64_t>(_size);
+  }
+
+  void write_index(const size_t _index) const {
+    *ar_ << static_cast<std::uint64_t>(_index);
+  }
+
+  void write_key(const std::string_view& _name) const {
+    *ar_ << std::string(_name);
+  }
+
   template <class T>
   void new_value(const T& _var) const {
     using Type = std::remove_cvref_t<T>;

include/rfl/parsing/Parser.hpp

@@ -34,6 +34,7 @@
 #include "Parser_span.hpp"
 #include "Parser_string_view.hpp"
 #include "Parser_tagged_union.hpp"
+#include "Parser_time_point.hpp"
 #include "Parser_tuple.hpp"
 #include "Parser_unique_ptr.hpp"
 #include "Parser_variant.hpp"