Условное сопоставление типов времени компиляции на основе параметра шаблона

Question

Как мне во время компиляции проверить, имеет ли параметр шаблона конкретное перечисление, и если это правда, получить это значение перечисления.

Я ищу что-то подобное для параметра шаблона T который может (или не может) иметь тип enum NeedsToAlign:

compile_time_if (T has NeedToAlign) {
 // only then compile the following
 EIGEN_MAKE_ALIGNED_OPERATOR_IF(typename T::NeedToAlign)
}

Читайте дальше, чтобы увидеть мою актуальную проблему:

Итак, у меня есть класс под названием Payload который определяет перечисление NeedsToAlign как показано ниже:

struct Payload<int N> {
 typedef Eigen::Matrix<float, N, 1> DataType;
 DataType data;

  enum {
    NeedToAlign = (sizeof(DataType)%16)==0,  ///< Check for alignement need
  };
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(EigenNeedsToAlign)
};

Хотя это не относится к моему актуальному вопросу, EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF() макрос необходим для использования библиотеки Eigen для генерации выровненных указателей для определенного фиксированного размера DataType,

Теперь скажите, что у меня есть другой шаблонный класс, который просто хранит переменную типа T, которая может быть типом Payload или более простыми типами, такими как int/float и т. Д.

template <typename T>
class A {
 T value;

// My goal:
// if T is of type Payload we need to enable the following:
// EIGEN_MAKE_ALIGNED_OPERATOR_IF(T::NeedToAlign) 

};

Обратите внимание, я не могу просто использовать EIGEN_MAKE_ALIGNED_OPERATOR_IF(typename T::NeedToAlign) так как я хочу class A также скомпилировать, скажем, T = Int.

Есть ли решение для повышения MPL для них? Это то, что я смог придумать до сих пор:

typedef typename boost::mpl::if_< 
        has_EigenNeedsToAlign<Payload>,
        typename Payload::NeedToAlign,
        boost::mpl::int_< 0 >
                                >::type result;
 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(result::value);

Но, конечно, вышесказанное не помогает T = int типы.

Один из способов найти решение состоит в том, чтобы выполнить некоторую частичную специализацию класса A для типов полезной нагрузки или T типы, которые имеют T::NeedToAlign. Но есть ли способ повышения MPL сделать это?

Как вы, наверное, поняли, я очень новичок в этом.

---

Update1:

Я выяснил один способ, который заключается в выводе класса A следующим образом:

template <typename T>
class A : public EigenAllocatorHelper<T>{
 T value;
 ....    
};

где EigenAllocatorHelper вводит соответствующее поведение путем частичной специализации (показано ниже):

template<typename T, class Enable = void>
class EigenAllocatorHelper {
};

BOOST_MPL_HAS_XXX_TRAIT_DEF(NeedsToAlignMPL)

template< typename T >
class EigenAllocatorHelper< T, typename boost::enable_if< has_NeedsToAlignMPL<T> >::type > {
public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(typename T::NeedsToAlign);
};

Также я должен был использовать typedef boost::mpl::int_<(sizeof(DataType)%16)==0> NeedToAlignMPL; поскольку mpl has_xxx не работал, когда я использовал простой enum.

Это решение выглядит хорошо для меня, и на самом деле я могу использовать это снова EigenAllocatorHelper класс в другом месте также. Но если есть лучшая магия MPL, которая не требует этого, дайте мне знать.

Answer 1

В настоящее время я использую следующее решение:

#include <boost/utility/enable_if.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/and.hpp>

//! The macro is used for enable_if if T is an Eigen Type
#define ENABLE_IF_EIGEN_TYPE(T)\
    typename boost::enable_if< is_eigen_type<T> >::type

/** The macro enables Eigen new() when required. T can be any type
 *
 * Example Usage:
 *  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_REQUIRED(Eigen::Vector2d) will enable Eigen's new()
 *  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_REQUIRED(Eigen::Vector3d) will NOT
 *  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_REQUIRED(int) will NOT
 */
#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_REQUIRED(T)\
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(requires_eigen_new_allign<T>::value)

namespace detail {
BOOST_MPL_HAS_XXX_TRAIT_DEF(Scalar)
BOOST_MPL_HAS_XXX_TRAIT_DEF(Index)
BOOST_MPL_HAS_XXX_TRAIT_DEF(StorageKind)
}

/**
 * Traits for checking if T is indeed an Eigen Type
 * @tparam T any Type
 *
 * Example Usage:
 * is_eigen_type<int>::value // evaluates to false
 * is_eigen_type<int>::type // evaluates to false_type
 * is_eigen_type<Eigen::Vector2d>::value // evaluates to true
 * is_eigen_type<Eigen::Vector2d>::type // true_type
 */
template<typename T>
struct is_eigen_type:
    boost::mpl::and_<
      detail::has_Scalar<T>,
      detail::has_Index<T>,
      detail::has_StorageKind<T> > {
};


template<class T, class Enable = void>
struct requires_eigen_new_allign {
  static const bool value = false;
};

template<class T>
struct requires_eigen_new_allign<T, ENABLE_IF_EIGEN_TYPE(T)> {
  typedef typename T::Scalar Scalar;
  static const bool value = (((T::SizeAtCompileTime) != Eigen::Dynamic)
      && ((sizeof(Scalar) * (T::SizeAtCompileTime)) % 16 == 0));
};