TypeTraits.hpp

#pragma once
 
#include <memory>
#include <type_traits>
 
namespace AMDiS
{
 
  template <class T>
  struct remove_cvref
  {
    using type = std::remove_cv_t<std::remove_reference_t<T>>;
  };
 
  template <class T>
  using remove_cvref_t = typename remove_cvref<T>::type;
 
  namespace Impl
  {
    template <class T>
    struct UnderlyingType
    {
      using type = T;
    };
 
    template <class T>
    struct UnderlyingType<T&>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<T*>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<T* const>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<std::reference_wrapper<T>>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<std::shared_ptr<T>>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<std::shared_ptr<T> const>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<std::unique_ptr<T>>
    {
      using type = typename UnderlyingType<T>::type;
    };
 
    template <class T>
    struct UnderlyingType<std::unique_ptr<T> const>
    {
      using type = typename UnderlyingType<T>::type;
    };
  }
 
  template <class T>
  using Underlying_t = typename Impl::UnderlyingType<T>::type;
 
 
  // overload for l-values
  template <class T>
  T& underlying(T& value)
  {
    return value;
  }
 
  // overload for l-value pointers
  template <class T>
  T& underlying(T* value)
  {
    return *value;
  }
 
  // overload for plain r-values is deleted
  template <class T>
  T underlying(T&& value) = delete;
 
  // overload for reference-wrappers
  template <class T>
  T& underlying(std::reference_wrapper<T> const& value)
  {
    return value.get();
  }
 
  // overload for shared_ptr
  template <class T>
  T& underlying(std::shared_ptr<T> const& value)
  {
    return *value;
  }
 
  // overload for unique_ptr
  template <class T>
  T& underlying(std::unique_ptr<T> const& value)
  {
    return *value;
  }
 
 
  #define FWD(...) static_cast<decltype(__VA_ARGS__)>(__VA_ARGS__)
 
#ifdef __GCC__
  #define TYPEOF(...) __typeof__(__VA_ARGS__)
#else
  #define TYPEOF(...) AMDiS::remove_cvref_t<decltype(__VA_ARGS__)>
#endif
 
 
  #define VALUE(...) TYPEOF(__VA_ARGS__)::value
 
  // ---------------------------------------------------------------------------
 
  template <class... Ts>
  struct Types {};
 
  template <class... Ts>
  using Types_t = Types<remove_cvref_t<Ts>...>;
 
 
  template <class T>
  using owner = T;
 
  struct NoOp
  {
    template <class... T>
    constexpr void operator()(T&&...) const { /* no nothing */ }
  };
 
  template <class Obj>
  auto makeUniquePtr(Obj&& obj)
  {
    return std::make_unique<TYPEOF(obj)>(FWD(obj));
  }
 
  template <class Obj>
  auto makeSharedPtr(Obj&& obj)
  {
    return std::make_shared<TYPEOF(obj)>(FWD(obj));
  }
 
  template <bool... b>
  using enable_if_all_t = std::enable_if_t<(b &&...)>;
 
} // end namespace AMDiS