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>
 
#if DUNE_HAVE_HEADER_EXPERIMENTAL_TYPE_TRAITS
#include <experimental/type_traits>
#endif
 
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 DUNE_HAVE_CXX_BOOL_CONSTANT
 
    using std::bool_constant;
 
#elif DUNE_HAVE_CXX_EXPERIMENTAL_BOOL_CONSTANT
 
    using std::experimental::bool_constant;
 
#else
 
    template <bool value>
    using bool_constant = std::integral_constant<bool, value>;
 
#endif
 
 
  namespace Impl {
 
    // 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(Impl::is_callable_helper<R, F, Args...>(PriorityTag<42>()))
  {};
 
 
  template <class F, class... Args>
  struct is_invocable :
      decltype(Impl::is_callable_helper<void, F, Args...>(PriorityTag<42>()))
  {};
 
  template <class R, class F, class... Args>
  struct is_invocable_r :
      decltype(Impl::is_callable_helper<R, F, Args...>(PriorityTag<42>()))
  {};
 
 
#if DUNE_HAVE_CXX_EXPERIMENTAL_IS_DETECTED
 
  using std::experimental::nonesuch;
  using std::experimental::detected_or;
  using std::experimental::is_detected;
  using std::experimental::detected_t;
  using std::experimental::is_detected_v;
  using std::experimental::detected_or_t;
  using std::experimental::is_detected_exact;
  using std::experimental::is_detected_exact_v;
  using std::experimental::is_detected_convertible;
  using std::experimental::is_detected_convertible_v;
 
#else // DUNE_HAVE_CXX_EXPERIMENTAL_IS_DETECTED
 
  // fallback version of std::experimental::is_detected et al., heavily scribbled
  // from cppreference.com (but there is actually not much implementation to the thing)
 
#ifndef DOXYGEN
 
  namespace Impl {
 
    // default version of detector, this gets matched on failure
    template<typename Default, typename Void, template<typename...> class Op, typename... Args>
    struct detector
    {
      using value_t = std::false_type;
      using type = Default;
    };
 
    // specialization of detector that matches if Op<Args...> can be instantiated
    template<typename Default, template<typename...> class Op, typename... Args>
    struct detector<Default, void_t<Op<Args...>>, Op, Args...>
    {
      using value_t = std::true_type;
      using type = Op<Args...>;
    };
 
  }
 
#endif // DOXYGEN
 
 
  struct nonesuch
  {
    nonesuch() = delete;
    ~nonesuch() = delete;
    nonesuch(const nonesuch&) = delete;
    void operator=(const nonesuch&) = delete;
  };
 
 
  template<typename Default, template<typename...> class Op, typename... Args>
  using detected_or = Impl::detector<Default,void,Op,Args...>;
 
 
  template<template<typename...> class Op, typename... Args>
  using is_detected = typename detected_or<nonesuch,Op,Args...>::value_t;
 
#ifdef __cpp_variable_templates
 
  template<template<typename...> class Op, typename... Args>
  constexpr bool is_detected_v = is_detected<Op,Args...>::value;
#endif // __cpp_variable_templates
 
 
  template<template<typename...> class Op, typename... Args>
  using detected_t = typename detected_or<nonesuch,Op,Args...>::type;
 
 
 
  template<typename Default, template<typename...> class Op, typename... Args>
  using detected_or_t = typename detected_or<Default,Op,Args...>::type;
 
 
  template<typename Expected, template<typename...> class Op, typename... Args>
  using is_detected_exact = std::is_same<Expected,detected_t<Op,Args...>>;
 
#ifdef __cpp_variable_templates
 
  template<typename Expected, template<typename...> class Op, typename... Args>
  constexpr bool is_detected_exact_v = is_detected_exact<Expected,Op,Args...>::value;
#endif // __cpp_variable_templates
 
 
  template<typename Target, template<typename...> class Op, typename... Args>
  using is_detected_convertible = std::is_convertible<Target,detected_t<Op,Args...>>;
 
#ifdef __cpp_variable_templates
 
  template<typename Target, template<typename...> class Op, typename... Args>
  constexpr bool is_detected_convertible_v = is_detected_convertible<Target,Op,Args...>::value;
#endif // __cpp_variable_templates
 
#endif // DUNE_HAVE_CXX_EXPERIMENTAL_IS_DETECTED
 
 
 
  // conjunction
  // -----------
 
  template< class... B >
  struct conjunction;
 
  template<>
  struct conjunction<>
    : std::true_type
  {};
 
  template< class B >
  struct conjunction< B >
    : B
  {};
 
  template< class B1, class... Bn >
  struct conjunction< B1, Bn... >
    : std::conditional_t< static_cast< bool >( B1::value ), conjunction< Bn... >, B1 >
  {};
 
 
 
  // disjunction
  // -----------
 
  template< class... B >
  struct disjunction;
 
  template<>
  struct disjunction<>
    : std::false_type
  {};
 
  template< class B >
  struct disjunction< B >
    : B
  {};
 
  template< class B1, class... Bn >
  struct disjunction< B1, Bn... >
    : std::conditional_t< static_cast< bool >( B1::value ), B1, disjunction< Bn... > >
  {};
 
  // negation
  // --------
 
  template<class B>
  struct negation : public bool_constant<!static_cast<bool>(B::value)>
  {};
 
} // namespace Std
 
} // namespace Dune
 
#endif // #ifndef DUNE_COMMON_STD_TYPE_TRAITS_HH