type_traits.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_COMMON_STD_TYPE_TRAITS_HH
#define DUNE_COMMON_STD_TYPE_TRAITS_HH
 
#include <type_traits>
#include <dune/common/typetraits.hh>
#include <dune/common/typeutilities.hh>
 
namespace Dune
{
 
namespace Std
{
 
  // to_false_type
  // -------------
 
  template< typename T >
  struct to_false_type : public std::false_type {};
 
 
 
  // to_true_type
  // ------------
 
  template< typename T >
  struct to_true_type : public std::true_type {};
 
 
#if __cpp_lib_bool_constant
 
    using std::bool_constant;
 
#elif __cpp_lib_experimental_bool_constant
 
    using std::experimental::bool_constant;
 
#else
 
    template <bool value>
    using bool_constant = std::integral_constant<bool, value>;
 
#endif
 
 
  namespace Imp {
 
    // If R is void we only need to check if F can be called
    // with given Args... list. If this is not possible
    // result_of_t is not defined and this overload is disabled.
    template<class R, class F, class... Args,
      std::enable_if_t<
        std::is_same<void_t<std::result_of_t<F(Args...)>>, R>::value
      , int> = 0>
    std::true_type is_callable_helper(PriorityTag<2>)
    { return {}; }
 
    // Check if result of F(Args...) can be converted to R.
    // If F cannot even be called with given Args... then
    // result_of_t is not defined and this overload is disabled.
    template<class R, class F, class... Args,
      std::enable_if_t<
        std::is_convertible<std::result_of_t<F(Args...)>, R>::value
      , int> = 0>
    std::true_type is_callable_helper(PriorityTag<1>)
    { return {}; }
 
    // If none of the above matches, F can either not be called
    // with given Args..., or the result cannot be converted to
    // void, or R is not void.
    template<class R, class F, class... Args>
    std::false_type is_callable_helper(PriorityTag<0>)
    { return {}; }
  }
 
  template <class D, class R= void>
  struct is_callable;
 
  template <class F, class... Args, class R>
  struct is_callable< F(Args...), R> :
      decltype(Imp::is_callable_helper<R, F, Args...>(PriorityTag<42>()))
  {};
 
 
 
 
 
 
 
 
} // namespace Std
 
} // namespace Dune
 
#endif // #ifndef DUNE_COMMON_STD_TYPE_TRAITS_HH