type_traits.hh

Go to the documentation of this file.

// -*- 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 __has_include(<experimental/type_traits>)
#include <experimental/type_traits>
#endif
 
namespace Dune
{
 
 
namespace Std
{
 
  // to_false_type
  // -------------
 
  template< typename T >
  struct [[deprecated("Will be removed after release 2.8. Use Dune::AlwaysFalse (from dune/common/typetraits.hh)")]] to_false_type : public std::false_type {};
 
 
 
  // to_true_type
  // ------------
 
  template< typename T >
  struct [[deprecated("Will be removed after release 2.8. Use Dune::AlwaysTrue (from dune/common/typetraits.hh)")]] to_true_type : public std::true_type {};
 
 
  using std::bool_constant;
 
 
  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<std::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 [[deprecated("Use std::is_invocable from <type_traits>. Will be removed after release 2.8")]] is_callable< F(Args...), R> :
      decltype(Impl::is_callable_helper<R, F, Args...>(PriorityTag<42>()))
  {};
 
 
  template <class F, class... Args>
  struct [[deprecated("Use std::is_invocable from <type_traits>. Will be removed after release 2.8")]] is_invocable :
      decltype(Impl::is_callable_helper<void, F, Args...>(PriorityTag<42>()))
  {};
 
  template <class R, class F, class... Args>
  struct [[deprecated("Use std::is_invocable_r from <type_traits>. Will be removed after release 2.8")]] 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, std::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 [[deprecated("Will be removed after release 2.8. Use std::conjuction instead.")]] conjunction
    : std::conjunction<B...>
  {};
 
 
  // disjunction
  // -----------
 
  template< class... B >
  struct [[deprecated("Will be removed after release 2.8. Use std::disjunction instead.")]] disjunction
    : std::disjunction<B...>
  {};
 
 
  // negation
  // --------
 
  template<class B>
  struct [[deprecated("Will be removed after release 2.8. Use std::negation instead.")]] negation
    : std::negation<B>
  {};
 
} // namespace Std
 
} // namespace Dune
 
#endif // #ifndef DUNE_COMMON_STD_TYPE_TRAITS_HH