Boost PFR as implicit fallback

include/boost/fusion/adapted/boost_pfr/tag_of_fallback.hpp

@@ -9,6 +9,7 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/tag_of_fwd.hpp>
+#include <boost/type_index/ctti_type_index.hpp>
 #include <boost/pfr/traits.hpp>
 #include <type_traits>
 
@@ -24,15 +25,52 @@ namespace boost { namespace fusion
 
     namespace detail
     {
+        // Helper function that returns true if `name` starts with `substr`
+        template <std::size_t N>
+        constexpr bool starts_with(const char* name, const char (&substr)[N]) noexcept {
+            static_assert(N > 0, "non a zero-terminated string passed");
+            for (std::size_t i = 0; i<N-1; ++i) {
+                if (name[i] != substr[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // Function that returns true if `T` declared in namespace `ns`
+        // got from here: https://www.boost.org/doc/libs/1_81_0/doc/html/boost_typeindex/examples.html#boost_typeindex.examples.c_14_checking_namespace_at_compi
+        // TODO: test for it
+        template <class T, std::size_t N>
+        constexpr bool in_namespace(const char (&ns)[N]) noexcept {
+            const char* name = boost::typeindex::ctti_type_index::type_id<T>().raw_name();
+
+            // Some compilers add `class ` or `struct ` before the namespace, so we need to skip those words first
+            if (detail::starts_with(name, "class ")) {
+                name += sizeof("class ") - 1;
+            } else if (detail::starts_with(name, "struct ")) {
+                name += sizeof("struct ") - 1;
+            }
+
+            return detail::starts_with(name, ns) && detail::starts_with(name + N - 1, "::");
+        }
+
+        template<typename T>
+        constexpr bool is_implicitly_reflectable_via_pfr() noexcept {
+            // TODO: check that T is complete
+            const auto possible_pfr = boost::pfr::is_implicitly_reflectable<
+                T, boost::pfr::boost_fusion_tag>::value;
+            const auto value = !std::is_array<T>::value
+                          && !detail::in_namespace<T>("boost::fusion")
+                          && !detail::in_namespace<T>("boost::mpl")
+                          && !detail::in_namespace<T>("mpl_")
+                          && possible_pfr;
+            return value;
+        }
+
         template <typename T>
-        struct tag_of_fallback<T, std::enable_if_t<std::is_same<T, T>::value>>
+        struct tag_of_fallback<T, std::enable_if_t<detail::is_implicitly_reflectable_via_pfr<T>()>>
         {
-            static constexpr auto possible_pfr = boost::pfr::is_implicitly_reflectable<
-                T, boost::pfr::boost_fusion_tag>::value;
-            using type = std::conditional_t<(!std::is_array<T>::value && possible_pfr)
-              , boost_pfr_tag
-              , non_fusion_tag
-            >;
+            using type = boost_pfr_tag;
         };
     }
 }}