Added static_asserts

Author: liuzicheng1987

include/rfl/internal/has_default_val_v.hpp

@@ -1,5 +1,7 @@
 #ifndef RFL_HASDEFAULTVALV_HPP_
 #define RFL_HASDEFAULTVALV_HPP_
+
+#include <array>
 #include <type_traits>
 
 #include "../NamedTuple.hpp"
@@ -11,6 +13,11 @@ namespace rfl::internal {
 template <class T>
 struct HasDefaultVal;
 
+template <class T>
+struct HasDefaultVal {
+  static constexpr bool value = false;
+};
+
 template <class... Fields>
 struct HasDefaultVal<NamedTuple<Fields...>> {
   static constexpr bool value =
@@ -20,7 +27,18 @@ struct HasDefaultVal<NamedTuple<Fields...>> {
 };
 
 template <class T>
-constexpr bool has_default_val_v = HasDefaultVal<named_tuple_t<T>>::value;
+  requires(std::is_class_v<T> && std::is_aggregate_v<T>)
+struct HasDefaultVal<T> : HasDefaultVal<named_tuple_t<T>> {};
+
+template <class T, size_t N>
+struct HasDefaultVal<std::array<T, N>> : HasDefaultVal<std::remove_cvref_t<T>> {
+};
+
+template <class T, size_t N>
+struct HasDefaultVal<T[N]> : HasDefaultVal<std::remove_cvref_t<T>> {};
+
+template <class T>
+constexpr bool has_default_val_v = HasDefaultVal<std::remove_cvref_t<T>>::value;
 
 }  // namespace rfl::internal
 

include/rfl/parsing/Parser_box.hpp

@@ -9,6 +9,7 @@
 #include "../atomic/is_atomic.hpp"
 #include "../atomic/remove_atomic_t.hpp"
 #include "../atomic/set_atomic.hpp"
+#include "../internal/has_default_val_v.hpp"
 #include "Parser_base.hpp"
 #include "schema/Type.hpp"
 
@@ -23,6 +24,12 @@ struct Parser<R, W, Box<T, C>, ProcessorsType> {
                                 const InputVarType& _var) noexcept {
     if constexpr (atomic::is_atomic_v<T>) {
       using RemoveAtomicT = atomic::remove_atomic_t<T>;
+
+      static_assert(!internal::has_default_val_v<RemoveAtomicT>,
+                    "Atomic types cannot be mixed with rfl::DefaultVal");
+      static_assert(!ProcessorsType::default_if_missing_,
+                    "Atomic types cannot be mixed with rfl::DefaultIfMissing");
+
       return Parser<R, W, RemoveAtomicT, ProcessorsType>::read(_r, _var)
           .transform([](auto&& _t) {
             auto atomic_box = Box<T>::make();

include/rfl/parsing/Parser_ref.hpp

@@ -10,6 +10,7 @@
 #include "../atomic/is_atomic.hpp"
 #include "../atomic/remove_atomic_t.hpp"
 #include "../atomic/set_atomic.hpp"
+#include "../internal/has_default_val_v.hpp"
 #include "Parser_base.hpp"
 #include "schema/Type.hpp"
 
@@ -23,6 +24,12 @@ struct Parser<R, W, Ref<T>, ProcessorsType> {
   static Result<Ref<T>> read(const R& _r, const InputVarType& _var) noexcept {
     if constexpr (atomic::is_atomic_v<T>) {
       using RemoveAtomicT = atomic::remove_atomic_t<T>;
+
+      static_assert(!internal::has_default_val_v<RemoveAtomicT>,
+                    "Atomic types cannot be mixed with rfl::DefaultVal");
+      static_assert(!ProcessorsType::default_if_missing_,
+                    "Atomic types cannot be mixed with rfl::DefaultIfMissing");
+
       return Parser<R, W, RemoveAtomicT, ProcessorsType>::read(_r, _var)
           .transform([](auto&& _t) {
             auto atomic_ref = Ref<T>::make();

include/rfl/parsing/Parser_shared_ptr.hpp

@@ -11,6 +11,7 @@
 #include "../atomic/is_atomic.hpp"
 #include "../atomic/remove_atomic_t.hpp"
 #include "../atomic/set_atomic.hpp"
+#include "../internal/has_default_val_v.hpp"
 #include "Parent.hpp"
 #include "Parser_base.hpp"
 #include "schema/Type.hpp"
@@ -31,6 +32,12 @@ struct Parser<R, W, std::shared_ptr<T>, ProcessorsType> {
                                          const InputVarType& _var) noexcept {
     if constexpr (atomic::is_atomic_v<T>) {
       using RemoveAtomicT = std::shared_ptr<atomic::remove_atomic_t<T>>;
+
+      static_assert(!internal::has_default_val_v<RemoveAtomicT>,
+                    "Atomic types cannot be mixed with rfl::DefaultVal");
+      static_assert(!ProcessorsType::default_if_missing_,
+                    "Atomic types cannot be mixed with rfl::DefaultIfMissing");
+
       return Parser<R, W, RemoveAtomicT, ProcessorsType>::read(_r, _var)
           .transform([](auto&& _t) {
             if (!_t) {
@@ -48,6 +55,7 @@ struct Parser<R, W, std::shared_ptr<T>, ProcessorsType> {
         return _r.template read_union<std::shared_ptr<T>, S>(_u);
       };
       return _r.to_union(_var).and_then(to_shared);
+
     } else {
       if (_r.is_empty(_var)) {
         return std::shared_ptr<T>();

include/rfl/parsing/Parser_unique_ptr.hpp

@@ -11,6 +11,7 @@
 #include "../atomic/is_atomic.hpp"
 #include "../atomic/remove_atomic_t.hpp"
 #include "../atomic/set_atomic.hpp"
+#include "../internal/has_default_val_v.hpp"
 #include "Parent.hpp"
 #include "Parser_base.hpp"
 #include "schema/Type.hpp"
@@ -31,6 +32,12 @@ struct Parser<R, W, std::unique_ptr<T>, ProcessorsType> {
                                          const InputVarType& _var) noexcept {
     if constexpr (atomic::is_atomic_v<T>) {
       using RemoveAtomicT = std::unique_ptr<atomic::remove_atomic_t<T>>;
+
+      static_assert(!internal::has_default_val_v<RemoveAtomicT>,
+                    "Atomic types cannot be mixed with rfl::DefaultVal");
+      static_assert(!ProcessorsType::default_if_missing_,
+                    "Atomic types cannot be mixed with rfl::DefaultIfMissing");
+
       return Parser<R, W, RemoveAtomicT, ProcessorsType>::read(_r, _var)
           .transform([](auto&& _t) {
             if (!_t) {
@@ -48,6 +55,7 @@ struct Parser<R, W, std::unique_ptr<T>, ProcessorsType> {
         return _r.template read_union<std::unique_ptr<T>, S>(_u);
       };
       return _r.to_union(_var).and_then(to_unique);
+
     } else {
       if (_r.is_empty(_var)) {
         return std::unique_ptr<T>();