template_constraints.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2018 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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

namespace internal
{
  namespace TemplateConstraints
  {
    // 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 <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;
};



/*
 * 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 <bool, typename> struct constraint_and_return_value;


template <typename T>
struct DEAL_II_DEPRECATED constraint_and_return_value<true,T>
{
  typedef T type;
};



template <typename T>
struct identity
{
  typedef T type;
};



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 <int N>
  struct DEAL_II_DEPRECATED int2type
  {};


  template <bool B>
  struct DEAL_II_DEPRECATED bool2type
  {};
}



template <typename T, typename U>
struct DEAL_II_DEPRECATED types_are_equal : std::is_same<T,U>
{};



namespace internal
{

  template <typename T, typename U>
  struct ProductTypeImpl
  {
    typedef decltype(std::declval<T>() * std::declval<U>()) type;
  };

}



template <typename T, typename U>
struct ProductType
{
  typedef typename internal::ProductTypeImpl<
  typename std::decay<T>::type, typename std::decay<U>::type>::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> >
  {
    typedef std::complex<T> type;
  };

  template <typename T, typename U>
  struct ProductTypeImpl<std::complex<T>,std::complex<U> >
  {
    typedef std::complex<typename ProductType<T,U>::type> type;
  };

  template <typename U>
  struct ProductTypeImpl<double,std::complex<U> >
  {
    typedef std::complex<typename ProductType<double,U>::type> type;
  };

  template <typename T>
  struct ProductTypeImpl<std::complex<T>,double>
  {
    typedef std::complex<typename ProductType<T,double>::type> type;
  };

  template <typename U>
  struct ProductTypeImpl<float,std::complex<U> >
  {
    typedef std::complex<typename ProductType<float,U>::type> type;
  };

  template <typename T>
  struct ProductTypeImpl<std::complex<T>,float>
  {
    typedef std::complex<typename ProductType<T,float>::type> type;
  };

}



template <typename T>
struct EnableIfScalar;


template <> struct EnableIfScalar<double>
{
  typedef double type;
};

template <> struct EnableIfScalar<float>
{
  typedef float type;
};

template <> struct EnableIfScalar<long double>
{
  typedef long double type;
};

template <> struct EnableIfScalar<int>
{
  typedef int type;
};

template <> struct EnableIfScalar<unsigned int>
{
  typedef unsigned int type;
};

template <typename T> struct EnableIfScalar<std::complex<T> >
{
  typedef std::complex<T> type;
};


DEAL_II_NAMESPACE_CLOSE

#endif