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
  {
  };
  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 >
  {
  };
  struct ArithmeticConversionTraits< T, U, {…};
  
  
  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; 
  };
  struct ArithmeticConversionTraits< T, U, typename std::enable_if<    std::is_arithmetic<T>::value {…};
  
  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
  {
  };
  struct IsArithmeticConversionValid {…};
  
  template <typename T, typename U>
  struct IsArithmeticConversionValid<T, U,
  typename std::conditional<false, ArithmeticConversionType<T, U>, void>::type >
  : std::true_type
  {
  };
  struct IsArithmeticConversionValid<T, U, {…};
  
  
  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)... );
  }
  constructFromArithmeticConversion( LHS const& lhs, RHS const& rhs, Args &&... args ) {…}

  template <typename T>
  struct ArithmeticConversionTraits<T, BigInteger,typename std::enable_if< std::is_integral<T>::value >::type >
  {
    using type = BigInteger;
  };
  struct ArithmeticConversionTraits<T, BigInteger,typename std::enable_if< std::is_integral<T>::value >::type > {…};
  
  template <typename U>
  struct ArithmeticConversionTraits<BigInteger, U,typename std::enable_if< std::is_integral<U>::value >::type >
  {
    using type = BigInteger;
  };
  struct ArithmeticConversionTraits<BigInteger, U,typename std::enable_if< std::is_integral<U>::value >::type > {…};
  
  template <>
  struct ArithmeticConversionTraits<BigInteger,BigInteger>
  {
    using type = BigInteger;
  };
  struct ArithmeticConversionTraits<BigInteger,BigInteger> {…};
} // namespace DGtal
 
 
#endif // !defined ArithmeticConversionTraits_h
 
#undef ArithmeticConversionTraits_RECURSES
#endif // else defined(ArithmeticConversionTraits_RECURSES)