template_constraints.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2022 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_template_constraints_h
#define dealii_template_constraints_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/complex_overloads.h>
 
#include <complex>
#include <utility>
 
DEAL_II_NAMESPACE_OPEN
 
// Detection idiom adapted from Version 2 of the C++ Extensions for Library
// Fundamentals, ISO/IEC TS 19568:2017
namespace internal
{
  namespace SupportsOperation
  {
    template <class...>
    using void_t = void;
 
    template <class Default,
              class AlwaysVoid,
              template <class...>
              class Op,
              class... Args>
    struct detector
    {
      using value_t = std::false_type;
      using type    = Default;
    };
 
    template <class Default, template <class...> class Op, class... Args>
    struct detector<Default, void_t<Op<Args...>>, Op, Args...>
    {
      using value_t = std::true_type;
      using type    = Op<Args...>;
    };
 
 
    struct nonesuch_base
    {};
 
    struct nonesuch : private nonesuch_base
    {
      ~nonesuch()                = delete;
      nonesuch(nonesuch const &) = delete;
      void
      operator=(nonesuch const &) = delete;
    };
 
    template <class Default, template <class...> class Op, class... Args>
    using detected_or = detector<Default, void, Op, Args...>;
 
    template <template <class...> class Op, class... Args>
    using is_detected = typename detected_or<nonesuch, Op, Args...>::value_t;
 
    template <template <class...> class Op, class... Args>
    using detected_t = typename detected_or<nonesuch, Op, Args...>::type;
 
    template <class Default, template <class...> class Op, class... Args>
    using detected_or_t = typename detected_or<Default, Op, Args...>::type;
 
    template <class Expected, template <class...> class Op, class... Args>
    using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
 
    template <class To, template <class...> class Op, class... Args>
    using is_detected_convertible =
      std::is_convertible<detected_t<Op, Args...>, To>;
  } // namespace SupportsOperation
 
 
  template <template <class...> class Op, class... Args>
  constexpr bool is_supported_operation =
    SupportsOperation::is_detected<Op, Args...>::value;
} // namespace internal
 
 
 
namespace internal
{
  namespace TemplateConstraints
  {
    // TODO: Once we are able to use DEAL_II_HAVE_CXX17, the following classes
    // can be made much simpler with the help of fold expressions, see
    // https://en.cppreference.com/w/cpp/language/fold
 
    // helper struct for is_base_of_all and all_same_as
    template <bool... Values>
    struct BoolStorage;
 
 
    template <bool... Values>
    struct all_true
    {
      static constexpr bool value =
        std::is_same<BoolStorage<Values..., true>,
                     BoolStorage<true, Values...>>::value;
    };
 
 
    template <bool... Values>
    struct any_true;
 
 
    template <bool V1, bool... Values>
    struct any_true<V1, Values...>
    {
      static constexpr bool value = V1 || any_true<Values...>::value;
    };
 
 
    template <>
    struct any_true<>
    {
      static constexpr bool value = false;
    };
  } // namespace TemplateConstraints
} // namespace internal
 
template <class Base, class... Derived>
struct is_base_of_all
{
  static constexpr bool value = internal::TemplateConstraints::all_true<
    std::is_base_of<Base, Derived>::value...>::value;
};
 
 
 
template <class Type, class... Types>
struct all_same_as
{
  static constexpr bool value = internal::TemplateConstraints::all_true<
    std::is_same<Type, Types>::value...>::value;
};
 
 
 
template <class Type, class... Types>
struct is_same_as_any_of
{
  static constexpr bool value = internal::TemplateConstraints::any_true<
    std::is_same<Type, Types>::value...>::value;
};
 
 
 
/*
 * A generalization of `std::enable_if` that only works if
 * <i>all</i> of the given boolean template parameters are
 * true.
 */
template <bool... Values>
struct enable_if_all
  : std::enable_if<internal::TemplateConstraints::all_true<Values...>::value>
{};
 
 
 
template <typename T>
using begin_and_end_t =
  decltype(std::begin(std::declval<T>()), std::end(std::declval<T>()));
 
template <typename T>
constexpr bool has_begin_and_end =
  internal::is_supported_operation<begin_and_end_t, T>;
 
 
 
template <typename T>
struct identity
{
  using type = T;
};
 
 
 
template <typename ArgType, typename ValueType>
struct always_return
{
  ValueType value;
  ValueType
  operator()(const ArgType &)
  {
    return value;
  }
};
 
 
 
struct PointerComparison
{
  template <typename T>
  static bool
  equal(const T *p1, const T *p2)
  {
    return (p1 == p2);
  }
 
 
  template <typename T, typename U>
  static bool
  equal(const T *, const U *)
  {
    return false;
  }
};
 
 
 
namespace internal
{
  template <typename T, typename U>
  struct ProductTypeImpl
  {
    using type = decltype(std::declval<T>() * std::declval<U>());
  };
 
} // namespace internal
 
 
 
template <typename T, typename U>
struct ProductType
{
  using type =
    typename internal::ProductTypeImpl<typename std::decay<T>::type,
                                       typename std::decay<U>::type>::type;
};
 
namespace internal
{
  // Annoyingly, there is no std::complex<T>::operator*(U) for scalars U
  // other than T (not even in C++11, or C++14). We provide our own overloads
  // in base/complex_overloads.h, but in order for them to work, we have to
  // manually specify all products we want to allow:
 
  template <typename T>
  struct ProductTypeImpl<std::complex<T>, std::complex<T>>
  {
    using type = std::complex<T>;
  };
 
  template <typename T, typename U>
  struct ProductTypeImpl<std::complex<T>, std::complex<U>>
  {
    using type = std::complex<typename ProductType<T, U>::type>;
  };
 
  template <typename U>
  struct ProductTypeImpl<double, std::complex<U>>
  {
    using type = std::complex<typename ProductType<double, U>::type>;
  };
 
  template <typename T>
  struct ProductTypeImpl<std::complex<T>, double>
  {
    using type = std::complex<typename ProductType<T, double>::type>;
  };
 
  template <typename U>
  struct ProductTypeImpl<float, std::complex<U>>
  {
    using type = std::complex<typename ProductType<float, U>::type>;
  };
 
  template <typename T>
  struct ProductTypeImpl<std::complex<T>, float>
  {
    using type = std::complex<typename ProductType<T, float>::type>;
  };
 
} // namespace internal
 
 
 
template <typename T>
struct EnableIfScalar;
 
 
template <>
struct EnableIfScalar<double>
{
  using type = double;
};
 
template <>
struct EnableIfScalar<float>
{
  using type = float;
};
 
template <>
struct EnableIfScalar<long double>
{
  using type = long double;
};
 
template <>
struct EnableIfScalar<int>
{
  using type = int;
};
 
template <>
struct EnableIfScalar<unsigned int>
{
  using type = unsigned int;
};
 
template <typename T>
struct EnableIfScalar<std::complex<T>>
{
  using type = std::complex<T>;
};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif