Morpheus_FormatTraits.hpp

 
#ifndef MORPHEUS_FORMAT_TRAITS_HPP
#define MORPHEUS_FORMAT_TRAITS_HPP
 
// #include <Morpheus_FormatTags.hpp>
#include <Morpheus_TypeTraits.hpp>
#include <Morpheus_SpaceTraits.hpp>
 
#include <impl/Morpheus_MatrixTags.hpp>
#include <impl/Morpheus_VectorTags.hpp>
 
#include <type_traits>
 
namespace Morpheus {
template <class T>
class is_matrix_container {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*,
      typename std::enable_if<Impl::has_matrix_tag<U>::value>::type* = nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
 
template <typename T>
inline constexpr bool is_matrix_container_v = is_matrix_container<T>::value;
 
template <class T>
class is_sparse_matrix_container {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*, typename std::enable_if<Impl::has_sparse_matrix_tag_v<U>>::type* =
              nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
 
template <typename T>
inline constexpr bool is_sparse_matrix_container_v =
    is_sparse_matrix_container<T>::value;
 
template <class T>
class is_dense_matrix_container {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*, typename std::enable_if<Impl::has_dense_matrix_tag_v<U>>::type* =
              nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
 
template <typename T>
inline constexpr bool is_dense_matrix_container_v =
    is_dense_matrix_container<T>::value;
 
template <class T>
class is_vector_container {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*,
      typename std::enable_if<Impl::has_vector_tag<U>::value>::type* = nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
 
template <typename T>
inline constexpr bool is_vector_container_v = is_vector_container<T>::value;
 
template <class T>
class is_container {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*, typename std::enable_if<is_matrix_container_v<U> ||
                                  is_vector_container_v<U>>::type* = nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
 
template <typename T>
inline constexpr bool is_container_v = is_container<T>::value;
 
template <class T>
class is_dynamic_matrix_container {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*,
      typename std::enable_if<Impl::has_dynamic_matrix_tag<U>::value>::type* =
          nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
 
template <typename T>
inline constexpr bool is_dynamic_matrix_container_v =
    is_dynamic_matrix_container<T>::value;
 
template <class T1, class T2>
class has_same_format {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U1, class U2>
  static yes& test(
      typename U1::tag*, typename U2::tag*,
      typename std::enable_if<
          is_container_v<U1> && is_container_v<U2> &&
          std::is_same<typename U1::tag, typename U2::tag>::value>::type* =
          nullptr);
 
  template <class U1, class U2>
  static no& test(...);
 
 public:
  static const bool value =
      sizeof(test<T1, T2>(nullptr, nullptr)) == sizeof(yes);
};
 
template <typename T1, typename T2>
inline constexpr bool has_same_format_v = has_same_format<T1, T2>::value;
 
template <class T1, class T2>
class is_compatible {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U1, class U2>
  static yes& test(
      U1*, U2*,
      typename std::enable_if<has_same_memory_space_v<U1, U2> &&
                              has_same_layout_v<U1, U2> &&
                              has_same_value_type_v<U1, U2> &&
                              has_same_index_type_v<U1, U2>>::type* = nullptr);
 
  template <class U1, class U2>
  static no& test(...);
 
 public:
  static const bool value =
      sizeof(test<T1, T2>(nullptr, nullptr)) == sizeof(yes);
};
 
template <typename T1, typename T2>
inline constexpr bool is_compatible_v = is_compatible<T1, T2>::value;
 
template <class T1, class T2>
class is_dynamically_compatible {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U1, class U2>
  static yes& test(
      typename U1::tag*, typename U2::tag*,
      typename std::enable_if<(is_dynamic_matrix_container<U1>::value ||
                               is_dynamic_matrix_container<U2>::value) &&
                              is_compatible_v<U1, U2>>::type* = nullptr);
 
  template <class U1, class U2>
  static no& test(...);
 
 public:
  static const bool value =
      sizeof(test<T1, T2>(nullptr, nullptr)) == sizeof(yes);
};
 
template <typename T1, typename T2>
inline constexpr bool is_dynamically_compatible_v =
    is_dynamically_compatible<T1, T2>::value;
 
template <typename T1, typename T2>
struct is_format_compatible
    : std::integral_constant<bool, has_same_format_v<T1, T2> &&
                                       is_compatible_v<T1, T2>> {};
 
template <typename T1, typename T2>
inline constexpr bool is_format_compatible_v =
    is_format_compatible<T1, T2>::value;
 
template <class T1, class T2>
class is_format_compatible_different_space {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U1, class U2>
  static yes& test(
      U1*, U2*,
      typename std::enable_if<
          !has_same_memory_space_v<U1, U2> && has_same_format_v<U1, U2> &&
          has_same_layout_v<U1, U2> && has_same_value_type_v<U1, U2> &&
          has_same_index_type_v<U1, U2>>::type* = nullptr);
 
  template <class U1, class U2>
  static no& test(...);
 
 public:
  static const bool value =
      sizeof(test<T1, T2>(nullptr, nullptr)) == sizeof(yes);
};
 
}  // namespace Morpheus
 
#endif  // MORPHEUS_FORMAT_TRAITS_HPP