Merge branch 'main' into f/init_struct

Author: liuzicheng1987

README.md

@@ -621,6 +621,7 @@ reflect-cpp supports the following containers from the C++ standard library:
 - `std::chrono::duration`
 - `std::filesystem::path`
 - `std::forward_list`
+- `std::inplace_vector` (C++26)
 - `std::map`
 - `std::multimap`
 - `std::multiset`

docs/content/custom_classes.md

@@ -129,3 +129,53 @@ class Person {
       int age;
 };
 ```
+
+## Example 4: Keeping your class an aggregate
+
+Declaring a constructor makes your class a non-aggregate, which costs you
+designated-initializer and aggregate initialization:
+
+```cpp
+struct Config {
+    Config(ReflectionType&&);   // this makes Config a non-aggregate...
+    int port;
+    bool tls;
+};
+
+// ...so this no longer compiles
+auto config = Config{.port = 443, .tls = true};
+```
+
+If you want to keep those, provide a static `from_reflection()` factory instead
+of a constructor:
+
+```cpp
+struct Config {
+    struct ConfigImpl {
+        rfl::Rename<"portNumber", int> port;
+        bool tls;
+    };
+
+    // 1) Publicly define `ReflectionType`
+    using ReflectionType = ConfigImpl;
+
+    // 2) A static factory, instead of a constructor
+    static Config from_reflection(const ReflectionType& _impl) {
+        return Config{.port = _impl.port(), .tls = _impl.tls};
+    }
+
+    // 3) Method called `reflection` that returns `ReflectionType`
+    ReflectionType reflection() const {
+        return ReflectionType{.port = port, .tls = tls};
+    }
+
+    int port;
+    bool tls;
+};
+
+// Config is still an aggregate, so this keeps working
+auto config = Config{.port = 443, .tls = true};
+```
+
+If a class provides both a `from_reflection()` factory and a converting
+constructor, the factory is used.

docs/content/processors.md

@@ -38,6 +38,7 @@ reflect-cpp currently supports the following processors:
 - `rfl::AddNamespacedTagsToVariants`
 - `rfl::AllowRawPtrs`
 - `rfl::DefaultIfMissing`
+- `rfl::DurationsAsCount`
 - `rfl::EnumNamesOnly`
 - `rfl::NoExtraFields`
 - `rfl::NoFieldNames`
@@ -290,6 +291,27 @@ have gotten had you read the following JSON string:
 Because you have not passed a default value to town, the default value
 of the type is used instead.
 
+### `rfl::DurationsAsCount`
+
+By default, `std::chrono::duration` types are written as an object containing
+the count and the unit. By passing the processor `rfl::DurationsAsCount`,
+they will be written and read as a plain count in the unit of the C++ type:
+
+```cpp
+struct MyStruct {
+  std::chrono::milliseconds timeout;
+};
+
+rfl::json::write<rfl::DurationsAsCount>(
+    MyStruct{.timeout = std::chrono::milliseconds(1500)});
+```
+
+The resulting JSON string looks like this:
+
+```json
+{"timeout":1500}
+```
+
 ### `rfl::EnumNamesOnly`
 
 By default, when reading an enum from a string, numeric values are accepted

docs/content/timestamps.md

@@ -116,3 +116,7 @@ The following units are supported: `std::chrono::nanoseconds`, `std::chrono::mic
 `std::chrono::milliseconds`, `std::chrono::seconds`, 
 `std::chrono::minutes`, `std::chrono::hours`, `std::chrono::days`,
 `std::chrono::weeks`, `std::chrono::months`, and `std::chrono::years`.
+
+To write and read durations as a plain count in the unit of the C++ type
+(e.g. `{"duration":10}`), pass the `rfl::DurationsAsCount` processor
+(see [processors](../processors)).

include/rfl.hpp

@@ -21,6 +21,7 @@
 #include "rfl/DefaultIfMissing.hpp"
 #include "rfl/DefaultVal.hpp"
 #include "rfl/Description.hpp"
+#include "rfl/DurationsAsCount.hpp"
 #include "rfl/EnumNamesOnly.hpp"
 #include "rfl/ExtraFields.hpp"
 #include "rfl/Field.hpp"

include/rfl/DurationsAsCount.hpp

@@ -0,0 +1,19 @@
+#ifndef RFL_DURATIONSASCOUNT_HPP_
+#define RFL_DURATIONSASCOUNT_HPP_
+
+namespace rfl {
+
+/// This is a 'fake' processor - it doesn't do much by itself, but its
+/// inclusion instructs parsers to write and read std::chrono::duration types
+/// as a plain count in the unit of the C++ type, instead of {count, unit}.
+struct DurationsAsCount {
+ public:
+  template <class StructType>
+  static auto process(auto&& _named_tuple) {
+    return _named_tuple;
+  }
+};
+
+}  // namespace rfl
+
+#endif

include/rfl/internal/HasFromReflectionMethod.hpp

@@ -0,0 +1,17 @@
+#ifndef RFL_INTERNAL_HASFROMREFLECTIONMETHOD_HPP_
+#define RFL_INTERNAL_HASFROMREFLECTIONMETHOD_HPP_
+
+#include <concepts>
+#include <utility>
+
+namespace rfl::internal {
+
+/// Satisfied by a type `T` providing `static T from_reflection(ReflectionType&&)`.
+template <class T>
+concept HasFromReflectionMethod = requires(typename T::ReflectionType&& _r) {
+  { T::from_reflection(std::move(_r)) } -> std::convertible_to<T>;
+};
+
+}  // namespace rfl::internal
+
+#endif

include/rfl/internal/durations_as_count_v.hpp

@@ -0,0 +1,32 @@
+#ifndef RFL_INTERNAL_DURATIONSASCOUNT_HPP_
+#define RFL_INTERNAL_DURATIONSASCOUNT_HPP_
+
+#include <type_traits>
+
+#include "../Processors.hpp"
+#include "../DurationsAsCount.hpp"
+
+namespace rfl::internal {
+
+template <class T>
+class durations_as_count;
+
+template <class T>
+class durations_as_count : public std::false_type {};
+
+template <>
+class durations_as_count<DurationsAsCount> : public std::true_type {};
+
+template <class Head, class... Tail>
+struct durations_as_count<Processors<Head, Tail...>> {
+  static constexpr bool value =
+      (durations_as_count<Head>::value || ... || durations_as_count<Tail>::value);
+};
+
+template <class T>
+constexpr bool durations_as_count_v =
+    durations_as_count<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+
+}  // namespace rfl::internal
+
+#endif

include/rfl/parsing/NamedTupleParser.hpp

@@ -11,11 +11,15 @@
 #include "../Result.hpp"
 #include "../internal/default_if_missing_v.hpp"
 #include "../internal/has_default_val_v.hpp"
+#include "../internal/has_reflection_method_v.hpp"
+#include "../internal/has_reflection_type_v.hpp"
 #include "../internal/is_attribute.hpp"
 #include "../internal/is_default_val_v.hpp"
 #include "../internal/is_extra_fields.hpp"
 #include "../internal/is_skip.hpp"
 #include "../internal/nth_element_t.hpp"
+#include "../internal/ptr_cast.hpp"
+#include "../num_fields.hpp"
 #include "../to_view.hpp"
 #include "AreReaderAndWriter.hpp"
 #include "Parent.hpp"
@@ -35,6 +39,35 @@ namespace rfl {
 template <class... Ps>
 Generic to_generic(const auto& _t);
 
+namespace internal {
+
+/// Satisfied by a type that carries a nested `ReflectionType` and can be
+/// unwrapped by decomposing it, like `rfl::Validator`.
+template <class T>
+concept IsReflectionTypeWrapper =
+    // We use `std::is_aggregate_v` and `num_fields` rather than `requires`
+    // because `requires`, well, requires an expression, but checking this via
+    // syntax would require a statement `const auto& [_] = _t`, which is not
+    // allowed in a `requires` clause.
+    has_reflection_type_v<T> && !has_reflection_method_v<T> &&
+    std::is_aggregate_v<T> && num_fields<T> == 1;
+
+/// Satisfied when the generic writer can serialize `T`, i.e. when a schema
+/// `default` can be produced for it. Every type is writable, except those that
+/// can be constructed from `ReflectionType`, but not converted back to it.
+template <class T>
+concept CanWriteGeneric =
+    !has_reflection_type_v<std::remove_cvref_t<T>> ||
+    has_reflection_method_v<std::remove_cvref_t<T>> ||
+    IsReflectionTypeWrapper<std::remove_cvref_t<T>>;
+
+/// Satisfied when a schema `default` can be emitted for the field type `T`:
+/// it must be a `DefaultVal` that satisfies `CanWriteGeneric`.
+template <class T>
+concept CanEmitDefault =
+    is_default_val_v<T> && CanWriteGeneric<typename T::Type>;
+
+}  // namespace internal
 }  // namespace rfl
 
 namespace rfl::parsing {
@@ -235,12 +268,12 @@ struct NamedTupleParser {
     if constexpr (!internal::is_skip_v<U> && !internal::is_extra_fields_v<U>) {
       // Add default value here
       auto s = Parser<R, W, U, ProcessorsType>::to_schema(_definitions);
-      if constexpr (!std::is_same_v<View, void>) {
+      if constexpr (!std::is_same_v<View, void> && internal::CanEmitDefault<U>) {
         s.variant_.visit([&](auto& value) {
           if constexpr (std::is_same_v<std::remove_cvref_t<decltype(value)>,
                                        schema::Type::DefaultVal>) {
             value.default_value_ =
-                rfl::to_generic((*rfl::get<_i>(*_view)).get());
+                rfl::to_generic<ProcessorsType>((*rfl::get<_i>(*_view)).get());
           }
         });
       }

include/rfl/parsing/ParserDuration.hpp

@@ -8,6 +8,7 @@
 #include "../Literal.hpp"
 #include "../Variant.hpp"
 #include "../always_false.hpp"
+#include "../internal/durations_as_count_v.hpp"
 #include "Parent.hpp"
 #include "Parser_base.hpp"
 #include "schema/Type.hpp"
@@ -55,13 +56,18 @@ struct ParserDuration {
    */
   static Result<DurationType> read(const R& _r,
                                    const InputVarType& _var) noexcept {
-    return Parser<R, W, RType, ProcessorsType>::read(_r, _var)
-        .and_then(to_duration)
-        .transform([](auto&& _duration) {
-          return _duration.visit([](auto&& _d) -> DurationType {
-            return std::chrono::duration_cast<DurationType>(std::move(_d));
+    if constexpr (internal::durations_as_count_v<ProcessorsType>) {
+      return Parser<R, W, Rep, ProcessorsType>::read(_r, _var).transform(
+          [](const Rep _count) { return DurationType(_count); });
+    } else {
+      return Parser<R, W, RType, ProcessorsType>::read(_r, _var)
+          .and_then(to_duration)
+          .transform([](auto&& _duration) {
+            return _duration.visit([](auto&& _d) -> DurationType {
+              return std::chrono::duration_cast<DurationType>(std::move(_d));
+            });
           });
-        });
+    }
   }
 
   /**
@@ -74,9 +80,13 @@ struct ParserDuration {
    */
   template <class P>
   static void write(const W& _w, const DurationType& _d, const P& _parent) {
-    const auto r =
-        RType{.count = static_cast<int64_t>(_d.count()), .unit = make_unit()};
-    return Parser<R, W, RType, ProcessorsType>::write(_w, r, _parent);
+    if constexpr (internal::durations_as_count_v<ProcessorsType>) {
+      Parser<R, W, Rep, ProcessorsType>::write(_w, _d.count(), _parent);
+    } else {
+      const auto r = RType{.count = static_cast<int64_t>(_d.count()),
+                           .unit = make_unit()};
+      Parser<R, W, RType, ProcessorsType>::write(_w, r, _parent);
+    }
   }
 
   /**
@@ -87,7 +97,11 @@ struct ParserDuration {
    */
   static schema::Type to_schema(
       std::map<std::string, schema::Type>* _definitions) {
-    return Parser<R, W, RType, ProcessorsType>::to_schema(_definitions);
+    if constexpr (internal::durations_as_count_v<ProcessorsType>) {
+      return Parser<R, W, Rep, ProcessorsType>::to_schema(_definitions);
+    } else {
+      return Parser<R, W, RType, ProcessorsType>::to_schema(_definitions);
+    }
   }
 
  private: