template_constraints.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2015 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

template <bool, typename> struct constraint_and_return_value;


template <typename T> struct 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);

  template <typename T, typename U>
  static bool equal (const T *, const U *);
};



namespace internal
{
  template <int N>
  struct int2type
  {};


  template <bool B>
  struct bool2type
  {};
}



template <typename T, typename U>
struct types_are_equal
{
  static const bool value = false;
};


template <typename T>
struct types_are_equal<T,T>
{
  static const bool value = true;
};



template <typename T, typename U>
struct ProductType
{
#ifdef DEAL_II_WITH_CXX11
  typedef decltype(std::declval<T>() * std::declval<U>()) type;
#endif
};

#ifndef DEAL_II_WITH_CXX11

template <typename T>
struct ProductType<T,T>
{
  typedef T type;
};

template <typename T>
struct ProductType<T,bool>
{
  typedef T type;
};

template <typename T>
struct ProductType<bool, T>
{
  typedef T type;
};

template <>
struct ProductType<bool,double>
{
  typedef double type;
};

template <>
struct ProductType<double,bool>
{
  typedef double type;
};

template <>
struct ProductType<double,float>
{
  typedef double type;
};

template <>
struct ProductType<float,double>
{
  typedef double type;
};

template <>
struct ProductType<double,long double>
{
  typedef long double type;
};

template <>
struct ProductType<long double,double>
{
  typedef long double type;
};

template <>
struct ProductType<double,int>
{
  typedef double type;
};

template <>
struct ProductType<int,double>
{
  typedef double type;
};

template <>
struct ProductType<float,int>
{
  typedef float type;
};

template <>
struct ProductType<int,float>
{
  typedef float type;
};

template <>
struct ProductType<double, unsigned int>
{
  typedef double type;
};

template <>
struct ProductType<unsigned int, double>
{
  typedef double type;
};

template <>
struct ProductType<float,unsigned int>
{
  typedef float type;
};

template <>
struct ProductType<unsigned int,float>
{
  typedef float type;
};

#endif

// 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 ProductType<std::complex<T>,std::complex<T> >
{
  typedef std::complex<T> type;
};

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

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

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


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

template <typename T>
struct ProductType<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;
};


// --------------- inline functions -----------------


template <typename T, typename U>
inline
bool
PointerComparison::equal (const T *, const U *)
{
  return false;
}



template <typename T>
inline
bool
PointerComparison::equal (const T *p1, const T *p2)
{
  return (p1==p2);
}


DEAL_II_NAMESPACE_CLOSE

#endif