static constexpr bool solve()

in include/ylt/struct_pack/reflection.hpp [807:864]

• 58 lines of code
• 30 McCabe index (conditional complexity)

      static constexpr bool solve() {
        if constexpr (user_defined_serialization<T>) {
          return false;
        }
        else if constexpr (std::is_same_v<T,std::monostate>) {
          return true;
        }
        else if constexpr (std::is_abstract_v<T>) {
          return false;
        }
        else if constexpr (varint_t<T,parent_tag>) {
          return false;
        }
        else if constexpr (is_compatible_v<T> || is_trivial_view_v<T>) {
          return ignore_compatible_field;
        }
        else if constexpr (std::is_enum_v<T> || std::is_fundamental_v<T>  || bitset<T>
#if (__GNUC__ || __clang__) && defined(STRUCT_PACK_ENABLE_INT128)
        || std::is_same_v<__int128,T> || std::is_same_v<unsigned __int128,T>
#endif
        ) {
          return true;
        }
        else if constexpr (array<T>) {
          return is_trivial_serializable<typename T::value_type,
                                        ignore_compatible_field>::value;
        }
        else if constexpr (c_array<T>) {
          return is_trivial_serializable<typename std::remove_all_extents<T>::type,
                                        ignore_compatible_field>::value;
        }
        else if constexpr (!pair<T> && tuple<T> && !is_trivial_tuple<T>) {
          return false;
        }
        else if constexpr (user_defined_refl<T>) {
          return false;
        }
        else if constexpr (container<T> || ylt::reflection::optional<T> || is_variant_v<T> ||
                          unique_ptr<T> || ylt::reflection::expected<T> || container_adapter<T>) {
          return false;
        }
        else if constexpr (pair<T>) {
          return is_trivial_serializable<typename T::first_type,
                                        ignore_compatible_field>::value &&
                is_trivial_serializable<typename T::second_type,
                                        ignore_compatible_field>::value;
        }
        else if constexpr (is_trivial_tuple<T>) {
          return class_visit_helper<T>(std::make_index_sequence<std::tuple_size_v<T>>{});
        }
        else if constexpr (std::is_class_v<T>) {
          constexpr auto tag = get_parent_tag<T>();
          using U = decltype(get_types<T>());
          return class_visit_helper<U , tag>(std::make_index_sequence<std::tuple_size_v<U>>{});
        }
        else
          return false;
      }