base_of_template concept

Author: aalkin

Framework/Core/include/Framework/ASoA.h

@@ -1704,29 +1704,29 @@ static constexpr auto haveKey(framework::pack<C...>, std::string const& key)
 void notFoundColumn(const char* label, const char* key);
 void missingOptionalPreslice(const char* label, const char* key);
 
-template <soa::soa_table T, bool OPT = false>
-static constexpr std::string getLabelFromTypeForKey(std::string const& key)
-{
-  if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
-    using Os = typename std::decay_t<T>::originals;
-    auto locate = haveKey(Os{}, key);
-    auto it = std::find_if(locate.begin(), locate.end(), [](auto const& x) { return x.first; });
-    if (it != locate.end()) {
-      return it->second;
-    }
-  } else {
-    auto locate = hasKey<std::decay_t<T>>(key);
-    if (locate.first) {
-      return locate.second;
-    }
-  }
-  if constexpr (!OPT) {
-    notFoundColumn(getLabelFromType<std::decay_t<T>>().data(), key.data());
-  } else {
-    return "[MISSING]";
-  }
-  O2_BUILTIN_UNREACHABLE();
-}
+// template <soa::soa_table T, bool OPT = false>
+// static constexpr std::string getLabelFromTypeForKey(std::string const& key)
+// {
+//   if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
+//     using Os = typename std::decay_t<T>::originals;
+//     auto locate = haveKey(Os{}, key);
+//     auto it = std::find_if(locate.begin(), locate.end(), [](auto const& x) { return x.first; });
+//     if (it != locate.end()) {
+//       return it->second;
+//     }
+//   } else {
+//     auto locate = hasKey<std::decay_t<T>>(key);
+//     if (locate.first) {
+//       return locate.second;
+//     }
+//   }
+//   if constexpr (!OPT) {
+//     notFoundColumn(getLabelFromType<std::decay_t<T>>().data(), key.data());
+//   } else {
+//     return "[MISSING]";
+//   }
+//   O2_BUILTIN_UNREACHABLE();
+// }
 
 template <with_originals T, bool OPT = false>
 static constexpr std::string getLabelFromTypeForKey(std::string const& key)

Framework/Core/include/Framework/ConfigParamRegistry.h

@@ -90,11 +90,11 @@ class ConfigParamRegistry
         return mStore->store().get<std::string>(key);
       } else if constexpr (std::is_same_v<T, std::string_view>) {
         return std::string_view{mStore->store().get<std::string>(key)};
-      } else if constexpr (is_base_of_template_v<std::vector, T>) {
+      } else if constexpr (base_of_template<std::vector, T>) {
         return vectorFromBranch<typename T::value_type>(mStore->store().get_child(key));
-      } else if constexpr (is_base_of_template_v<o2::framework::Array2D, T>) {
+      } else if constexpr (base_of_template<o2::framework::Array2D, T>) {
         return array2DFromBranch<typename T::element_t>(mStore->store().get_child(key));
-      } else if constexpr (is_base_of_template_v<o2::framework::LabeledArray, T>) {
+      } else if constexpr (base_of_template<o2::framework::LabeledArray, T>) {
         return labeledArrayFromBranch<typename T::element_t>(mStore->store().get_child(key));
       } else if constexpr (std::is_same_v<T, boost::property_tree::ptree>) {
         return mStore->store().get_child(key);

Framework/Foundation/include/Framework/Traits.h

@@ -41,19 +41,27 @@ struct always_static_assert : std::false_type {
 template <typename... T>
 inline constexpr bool always_static_assert_v = always_static_assert<T...>::value;
 
-template <template <typename...> class base, typename derived>
-struct is_base_of_template_impl {
-  template <typename... Ts>
-  static constexpr std::true_type test(const base<Ts...>*);
-  static constexpr std::false_type test(...);
-  using type = decltype(test(std::declval<derived*>()));
-};
+// template <template <typename...> class base, typename derived>
+// struct is_base_of_template_impl {
+//   template <typename... Ts>
+//   static constexpr std::true_type test(const base<Ts...>*);
+//   static constexpr std::false_type test(...);
+//   using type = decltype(test(std::declval<derived*>()));
+// };
+
+// template <template <typename...> class base, typename derived>
+// using is_base_of_template = typename is_base_of_template_impl<base, derived>::type;
 
-template <template <typename...> class base, typename derived>
-using is_base_of_template = typename is_base_of_template_impl<base, derived>::type;
+// template <template <typename...> class base, typename derived>
+// inline constexpr bool is_base_of_template_v = is_base_of_template<base, derived>::value;
+
+template <template <typename...> typename B, typename D>
+concept base_of_template = requires {
+  []<typename... Ts>(B<Ts...>*){ }(std::declval<D*>());
+};
 
-template <template <typename...> class base, typename derived>
-inline constexpr bool is_base_of_template_v = is_base_of_template<base, derived>::value;
+template <template <typename...> typename B, typename D>
+constexpr bool is_base_of_template_v = base_of_template<B, D>;
 
 } // namespace o2::framework