ArithmeticConversionTraits.h

 
#pragma once
 
#if defined(ArithmeticConversionTraits_RECURSES)
#error Recursive header files inclusion detected in ArithmeticConversionTraits.h
#else // defined(ArithmeticConversionTraits_RECURSES)
#define ArithmeticConversionTraits_RECURSES
 
#if !defined ArithmeticConversionTraits_h
#define ArithmeticConversionTraits_h
 
// Inclusions
#include <type_traits>
#include "DGtal/base/Common.h"
 
namespace DGtal
{
 
  // template class ArithmeticConversionTraits
  template <typename T, typename U, typename Enable = void>
  struct ArithmeticConversionTraits
  {
  };
 
  template <typename T, typename U>
  struct ArithmeticConversionTraits< T, U,
      typename std::enable_if<
           ! std::is_same< T, typename std::remove_cv< typename std::remove_reference<T>::type >::type >::value
        || ! std::is_same< U, typename std::remove_cv< typename std::remove_reference<U>::type >::type >::value >::type >
    : ArithmeticConversionTraits<
        typename std::remove_cv< typename std::remove_reference<T>::type >::type,
        typename std::remove_cv< typename std::remove_reference<U>::type >::type >
  {
  };
 
 
  template <typename T, typename U>
  struct ArithmeticConversionTraits< T, U,
      typename std::enable_if<    std::is_arithmetic<T>::value
                               && std::is_arithmetic<U>::value >::type >
  {
    using type = typename std::common_type<T, U>::type; 
  };
 
  template <typename T, typename U>
  using ArithmeticConversionType = typename ArithmeticConversionTraits<T, U>::type;
 
  template <typename T, typename U, typename Enable = void>
  struct IsArithmeticConversionValid
    : std::false_type
  {
  };
 
  template <typename T, typename U>
  struct IsArithmeticConversionValid<T, U,
      typename std::conditional<false, ArithmeticConversionType<T, U>, void>::type >
    : std::true_type
  {
  };
 
 
  template <
    typename LHS,
    typename RHS,
    typename... Args >
  inline
  ArithmeticConversionType<LHS, RHS>
  constructFromArithmeticConversion( LHS const& lhs, RHS const& rhs, Args &&... args )
    {
      boost::ignore_unused_variable_warning(lhs);
      boost::ignore_unused_variable_warning(rhs);
 
      return ArithmeticConversionType<LHS, RHS>( std::forward<Args>(args)... );
    }
 
#ifdef WITH_GMP
  template <typename T, typename GMP1, typename GMP2>
  struct ArithmeticConversionTraits<T, __gmp_expr<GMP1, GMP2>,
      typename std::enable_if< std::is_integral<T>::value >::type >
  {
    using type = BigInteger;
  };
 
  template <typename GMP1, typename GMP2, typename U>
  struct ArithmeticConversionTraits<__gmp_expr<GMP1, GMP2>, U,
      typename std::enable_if< std::is_integral<U>::value >::type >
  {
    using type = BigInteger;
  };
 
  template <typename GMPL1, typename GMPL2, typename GMPR1, typename GMPR2>
  struct ArithmeticConversionTraits<__gmp_expr<GMPL1, GMPL2>, __gmp_expr<GMPR1, GMPR2>>
  {
    using type = BigInteger;
  };
#endif
 
} // namespace DGtal
 
#endif // !defined ArithmeticConversionTraits_h
 
#undef ArithmeticConversionTraits_RECURSES
#endif // else defined(ArithmeticConversionTraits_RECURSES)