IntegralConstant.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#ifndef EIGEN_INTEGRAL_CONSTANT_H
#define EIGEN_INTEGRAL_CONSTANT_H
 
namespace Eigen {
 
namespace internal {
 
template<int N> class FixedInt;
template<int N> class VariableAndFixedInt;
 
template<int N> class FixedInt
{
public:
  static const int value = N;
  EIGEN_CONSTEXPR operator int() const { return value; }
  FixedInt() {}
  FixedInt( VariableAndFixedInt<N> other) {
    #ifndef EIGEN_INTERNAL_DEBUGGING
    EIGEN_UNUSED_VARIABLE(other);
    #endif
    eigen_internal_assert(int(other)==N);
  }
 
  FixedInt<-N> operator-() const { return FixedInt<-N>(); }
  template<int M>
  FixedInt<N+M> operator+( FixedInt<M>) const { return FixedInt<N+M>(); }
  template<int M>
  FixedInt<N-M> operator-( FixedInt<M>) const { return FixedInt<N-M>(); }
  template<int M>
  FixedInt<N*M> operator*( FixedInt<M>) const { return FixedInt<N*M>(); }
  template<int M>
  FixedInt<N/M> operator/( FixedInt<M>) const { return FixedInt<N/M>(); }
  template<int M>
  FixedInt<N%M> operator%( FixedInt<M>) const { return FixedInt<N%M>(); }
  template<int M>
  FixedInt<N|M> operator|( FixedInt<M>) const { return FixedInt<N|M>(); }
  template<int M>
  FixedInt<N&M> operator&( FixedInt<M>) const { return FixedInt<N&M>(); }
 
#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
  // Needed in C++14 to allow fix<N>():
  FixedInt operator() () const { return *this; }
 
  VariableAndFixedInt<N> operator() (int val) const { return VariableAndFixedInt<N>(val); }
#else
  FixedInt ( FixedInt<N> (*)() ) {}
#endif
 
#if EIGEN_HAS_CXX11
  FixedInt(std::integral_constant<int,N>) {}
#endif
};
 
template<int N> class VariableAndFixedInt
{
public:
  static const int value = N;
  operator int() const { return m_value; }
  VariableAndFixedInt(int val) { m_value = val; }
protected:
  int m_value;
};
 
template<typename T, int Default=Dynamic> struct get_fixed_value {
  static const int value = Default;
};
 
template<int N,int Default> struct get_fixed_value<FixedInt<N>,Default> {
  static const int value = N;
};
 
#if !EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
template<int N,int Default> struct get_fixed_value<FixedInt<N> (*)(),Default> {
  static const int value = N;
};
#endif
 
template<int N,int Default> struct get_fixed_value<VariableAndFixedInt<N>,Default> {
  static const int value = N ;
};
 
template<typename T, int N, int Default>
struct get_fixed_value<variable_if_dynamic<T,N>,Default> {
  static const int value = N;
};
 
template<typename T> EIGEN_DEVICE_FUNC Index get_runtime_value(const T &x) { return x; }
#if !EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
template<int N> EIGEN_DEVICE_FUNC Index get_runtime_value(FixedInt<N> (*)()) { return N; }
#endif
 
// Cleanup integer/FixedInt/VariableAndFixedInt/etc types:
 
// By default, no cleanup:
template<typename T, int DynamicKey=Dynamic, typename EnableIf=void> struct cleanup_index_type { typedef T type; };
 
// Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index
template<typename T, int DynamicKey> struct cleanup_index_type<T,DynamicKey,typename internal::enable_if<internal::is_integral<T>::value>::type> { typedef Index type; };
 
#if !EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
// In c++98/c++11, fix<N> is a pointer to function that we better cleanup to a true FixedInt<N>:
template<int N, int DynamicKey> struct cleanup_index_type<FixedInt<N> (*)(), DynamicKey> { typedef FixedInt<N> type; };
#endif
 
// If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value:
template<int N, int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> { typedef FixedInt<N> type; };
// If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index):
template<int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<DynamicKey>, DynamicKey> { typedef Index type; };
 
#if EIGEN_HAS_CXX11
template<int N, int DynamicKey> struct cleanup_index_type<std::integral_constant<int,N>, DynamicKey> { typedef FixedInt<N> type; };
#endif
 
} // end namespace internal
 
#ifndef EIGEN_PARSED_BY_DOXYGEN
 
#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
template<int N>
static const internal::FixedInt<N> fix{};
#else
template<int N>
inline internal::FixedInt<N> fix() { return internal::FixedInt<N>(); }
 
// The generic typename T is mandatory. Otherwise, a code like fix<N> could refer to either the function above or this next overload.
// This way a code like fix<N> can only refer to the previous function.
template<int N,typename T>
inline internal::VariableAndFixedInt<N> fix(T val) { return internal::VariableAndFixedInt<N>(internal::convert_index<int>(val)); }
#endif
 
#else // EIGEN_PARSED_BY_DOXYGEN
 
template<int N>
static const auto fix();
 
template<int N>
static const auto fix(int val);
 
#endif // EIGEN_PARSED_BY_DOXYGEN
 
} // end namespace Eigen
 
#endif // EIGEN_INTEGRAL_CONSTANT_H