Morpheus_ContainerFactory.hpp

 
#ifndef MORPHEUS_CONTAINER_FACTORY_HPP
#define MORPHEUS_CONTAINER_FACTORY_HPP
 
#include <impl/Morpheus_ContainerFactory_Impl.hpp>
 
#include <type_traits>
 
namespace Morpheus {
 
struct Default {};
template <class T>
class is_default {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*, typename std::enable_if<std::is_same<U, Default>::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_default_v = is_default<T>::value;
template <typename ContainerType, typename TypeSet>
struct UnaryContainer {
  using proxy = typename Impl::UnaryContainerProxy<ContainerType, TypeSet>;
  using type  = typename proxy::type;
 
  using value_type   = typename proxy::value_type;
  using index_type   = typename proxy::index_type;
  using array_layout = typename proxy::array_layout;
  using backend      = typename proxy::backend;
};
 
template <typename ContainerType1, typename ContainerType2>
struct BinaryContainer {
  using type1 = ContainerType1;
  using type2 = ContainerType2;
};
template <typename Container, typename U>
struct generate_unary_typelist {
  using type = typename Impl::generate_unary_typelist<Container, U>::type;
};
 
// Returns a TypeList<Binary1<>, Binary2<>....>
template <typename List1, typename List2>
struct generate_binary_typelist {
  using type =
      typename Impl::generate_binary_typelist_proxy<List1, List2>::type;
};
}  // namespace Morpheus
 
#endif  // MORPHEUS_CONTAINER_FACTORY_HPP