meta.h

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits>
 
#define TVM_CREATE_HAS_MEMBER_TYPE_TRAIT_FOR(Type)                                            \
  namespace tvm::internal                                                                     \
  {                                                                                           \
  struct has_type_##Type##_helper                                                             \
  {                                                                                           \
    template<typename T>                                                                      \
    std::false_type has(...);                                                                 \
                                                                                              \
    template<typename T>                                                                      \
    std::true_type has(typename T::Type *);                                                   \
  };                                                                                          \
                                                                                              \
  template<typename T>                                                                        \
  using has_public_member_type_##Type = decltype(has_type_##Type##_helper{}.has<T>(nullptr)); \
  }
 
namespace tvm
{
namespace internal
{
template<template<typename...> class Base>
struct is_base
{
  template<typename... T>
  static std::true_type check(Base<T...> const volatile &);
  static std::false_type check(...);
};
 
template<typename T, template<typename...> class Base>
constexpr bool derives_from()
{ return decltype(is_base<Base>::check(std::declval<const T &>()))::value; }
 
template<typename T, typename Base>
constexpr bool derives_from()
{ return std::is_base_of_v<Base, T>; }
 
template<typename T, typename... Base>
using enable_for_t = std::enable_if_t<(... || (std::is_same_v<T, Base> || derives_from<T, Base>())), int>;
 
template<typename T, template<typename...> class... Base>
using enable_for_templated_t = std::enable_if_t<(... || derives_from<T, Base>()), int>;
 
template<typename T, template<typename...> class... Base>
using disable_for_templated_t = std::enable_if_t<!(... || derives_from<T, Base>()), int>;
 
template<typename T>
class always_true : public std::true_type
{};
 
template<typename T>
class always_false : public std::false_type
{};
 
template<typename T, bool c>
using const_if = std::conditional<c, const T, T>;
 
template<typename T, bool c>
using const_if_t = typename const_if<T, c>::type;
 
} // namespace internal
} // namespace tvm