Only check for duplicate field names when absolutely necessary

Author: liuzicheng1987

include/rfl/Literal.hpp

@@ -413,9 +413,6 @@ class Literal {
   static_assert(sizeof...(fields_) <= std::numeric_limits<ValueType>::max(),
                 "Too many fields.");
 
-  static_assert(sizeof...(fields_) <= 1 || !has_duplicates(),
-                "Duplicate strings are not allowed in a Literal.");
-
  private:
   /// The underlying value.
   ValueType value_;

include/rfl/internal/to_ptr_field_tuple.hpp

@@ -12,19 +12,22 @@
 #include "to_ptr_field.hpp"
 #include "wrap_in_fields.hpp"
 
-namespace rfl {
-namespace internal {
+namespace rfl::internal {
 
 template <class T>
 auto to_ptr_field_tuple(T& _t) {
   if constexpr (std::is_pointer_v<std::remove_cvref_t<T>>) {
     return to_ptr_field_tuple(*_t);
+
   } else if constexpr (is_named_tuple_v<T>) {
     return nt_to_ptr_named_tuple(_t).fields();
+
   } else if constexpr (has_fields<T>()) {
     return bind_to_tuple(_t, [](auto* _ptr) { return to_ptr_field(*_ptr); });
+
   } else if constexpr (is_empty<T>()) {
     return rfl::Tuple();
+
   } else {
     using FieldNames = field_names_t<T>;
     auto tup =
@@ -33,7 +36,6 @@ auto to_ptr_field_tuple(T& _t) {
   }
 }
 
-}  // namespace internal
-}  // namespace rfl
+}  // namespace rfl::internal
 
 #endif

include/rfl/internal/to_ptr_named_tuple.hpp

@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_TO_PTR_NAMED_TUPLE_HPP_
 #define RFL_INTERNAL_TO_PTR_NAMED_TUPLE_HPP_
 
-
 #include "../Tuple.hpp"
 #include "../always_false.hpp"
 #include "../field_names_t.hpp"
@@ -12,11 +11,12 @@
 #include "is_empty.hpp"
 #include "is_field.hpp"
 #include "is_named_tuple.hpp"
+#include "no_duplicate_field_names.hpp"
 #include "to_flattened_ptr_tuple.hpp"
 #include "to_ptr_field_tuple.hpp"
+#include "to_ptr_tuple.hpp"
 
-namespace rfl {
-namespace internal {
+namespace rfl::internal {
 
 template <class PtrFieldTuple>
 auto flatten_ptr_field_tuple(PtrFieldTuple& _t) {
@@ -34,8 +34,7 @@ auto flatten_ptr_field_tuple(PtrFieldTuple& _t) {
 
   return [&]<int... _is>(std::integer_sequence<int, _is...>) {
     return rfl::tuple_cat(get_one(std::integral_constant<int, _is>{})...);
-  }
-  (std::make_integer_sequence<int, size>());
+  }(std::make_integer_sequence<int, size>());
 }
 
 template <class PtrFieldTuple>
@@ -48,7 +47,12 @@ auto field_tuple_to_named_tuple(PtrFieldTuple& _ptr_field_tuple) {
     return rfl::apply(ft_to_nt, std::move(_ptr_field_tuple));
   } else {
     const auto flattened_tuple = flatten_ptr_field_tuple(_ptr_field_tuple);
-    return rfl::apply(ft_to_nt, flattened_tuple);
+    auto named_tuple = rfl::apply(ft_to_nt, flattened_tuple);
+    static_assert(
+        no_duplicate_field_names<
+            typename std::remove_cvref_t<decltype(named_tuple)>::Fields>(),
+        "Flattening created duplicate field names.");
+    return named_tuple;
   }
 }
 
@@ -59,22 +63,40 @@ auto to_ptr_named_tuple(T&& _t) {
   if constexpr (has_fields<std::remove_cvref_t<T>>()) {
     if constexpr (std::is_pointer_v<std::remove_cvref_t<T>>) {
       return to_ptr_named_tuple(*_t);
+
     } else if constexpr (is_named_tuple_v<std::remove_cvref_t<T>>) {
       return nt_to_ptr_named_tuple(_t);
+
     } else {
       auto ptr_field_tuple = to_ptr_field_tuple(_t);
       return field_tuple_to_named_tuple(ptr_field_tuple);
     }
+
   } else if constexpr (is_empty<T>()) {
     return rfl::NamedTuple<>();
+
   } else {
-    using FieldNames = rfl::field_names_t<T>;
-    auto flattened_ptr_tuple = to_flattened_ptr_tuple(_t);
-    return copy_flattened_tuple_to_named_tuple<FieldNames>(flattened_ptr_tuple);
+    auto ptr_tuple = to_ptr_tuple(_t);
+
+    using PtrTuple = std::remove_cvref_t<decltype(ptr_tuple)>;
+
+    if constexpr (!has_flatten_fields<PtrTuple>()) {
+      return copy_flattened_tuple_to_named_tuple<field_names_t<T>>(ptr_tuple);
+
+    } else {
+      using FieldNames = rfl::field_names_t<T>;
+      auto flattened_ptr_tuple = to_flattened_ptr_tuple(_t);
+      auto named_tuple =
+          copy_flattened_tuple_to_named_tuple<FieldNames>(flattened_ptr_tuple);
+      static_assert(
+          no_duplicate_field_names<
+              typename std::remove_cvref_t<decltype(named_tuple)>::Fields>(),
+          "Flattening created duplicate field names.");
+      return named_tuple;
+    }
   }
 }
 
-}  // namespace internal
-}  // namespace rfl
+}  // namespace rfl::internal
 
 #endif

include/rfl/parsing/NamedTupleParser.hpp

@@ -9,16 +9,12 @@
 
 #include "../NamedTuple.hpp"
 #include "../Result.hpp"
-#include "../always_false.hpp"
 #include "../internal/default_if_missing_v.hpp"
 #include "../internal/has_default_val_v.hpp"
-#include "../internal/is_array.hpp"
 #include "../internal/is_attribute.hpp"
-#include "../internal/is_basic_type.hpp"
 #include "../internal/is_default_val_v.hpp"
 #include "../internal/is_extra_fields.hpp"
 #include "../internal/is_skip.hpp"
-#include "../internal/no_duplicate_field_names.hpp"
 #include "../internal/nth_element_t.hpp"
 #include "../internal/ptr_cast.hpp"
 #include "../to_view.hpp"
@@ -35,8 +31,7 @@
 #include "schema/Type.hpp"
 #include "to_single_error_message.hpp"
 
-namespace rfl {
-namespace parsing {
+namespace rfl::parsing {
 
 template <class R, class W, bool _ignore_empty_containers, bool _all_required,
           bool _no_field_names, class ProcessorsType, class... FieldTypes>
@@ -85,8 +80,6 @@ struct NamedTupleParser {
    */
   static Result<NamedTuple<FieldTypes...>> read(
       const R& _r, const InputVarType& _var) noexcept {
-    static_assert(
-        internal::no_duplicate_field_names<typename NamedTupleType::Fields>());
     alignas(NamedTuple<FieldTypes...>) unsigned char
         buf[sizeof(NamedTuple<FieldTypes...>)];
     auto ptr = internal::ptr_cast<NamedTuple<FieldTypes...>*>(&buf);
@@ -116,8 +109,6 @@ struct NamedTupleParser {
                    std::optional<Error>>
   read_view(const R& _r, const InputVarType& _var,
             NamedTuple<FieldTypes...>* _view) noexcept {
-    static_assert(
-        internal::no_duplicate_field_names<typename NamedTupleType::Fields>());
     if constexpr (_no_field_names) {
       auto arr = _r.to_array(_var);
       if (!arr) [[unlikely]] {
@@ -146,8 +137,6 @@ struct NamedTupleParser {
   static std::optional<Error> read_view_with_default(
       const R& _r, const InputVarType& _var,
       NamedTuple<FieldTypes...>* _view) noexcept {
-    static_assert(
-        internal::no_duplicate_field_names<typename NamedTupleType::Fields>());
     if constexpr (_no_field_names) {
       auto arr = _r.to_array(_var);
       if (!arr) [[unlikely]] {
@@ -390,7 +379,6 @@ struct NamedTupleParser {
   }
 };
 
-}  // namespace parsing
-}  // namespace rfl
+}  // namespace rfl::parsing
 
 #endif