MeVis/Foundation/Sources/ML/include/mlTypeTraits.h

Go to the documentation of this file.

// **InsertLicense** code
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------

#ifndef __mlTypeTraits_H
#define __mlTypeTraits_H

#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif

#ifndef __mlRangeCasts_H
// we need the _ml_numeric_limits templates from this file
#include "mlRangeCasts.h"
#endif

// needed to define type traits for complex types:
#include "mlSystemWarningsDisable.h"
#include <complex>
#include "mlSystemWarningsRestore.h"

ML_START_NAMESPACE


template <typename T>
struct TypeTraits
{
  typedef void ComponentType;
  typedef void IntermediateType;

  enum {
    dataType            = ML_INVALID_DATA_TYPE, 
    isBuiltInFloatType  = false, 
    isBuiltInIntegerType= false, 
    isBuiltInSignedType = false, 
    isScalarType        = false, 
    isStandardType      = false, 
    is8BitInteger       = false, 
    is16BitInteger      = false, 
    is32BitInteger      = false, 
    is64BitInteger      = false, 
    is8_16_32BitInteger = false, 
    isUnknown           = true   
  };

  static inline bool matches(MLDataType) { return true; }
  static inline MLDataType getDataType() { return dataType; }
};

template <int dataTypeId> struct DataTypeSelector {};

// Flags for TypeTraits (anonymous, shall only be used for TypeTrait setup.
enum {
  ML_INTEGER_TYPE     = 0x01, // Flag that is used internally for TypeTraits
  ML_FLOAT_TYPE       = 0x02, // Flag that is used internally for TypeTraits
  ML_SIGNED_TYPE      = 0x04  // Flag that is used internally for TypeTraits
};

#define _ML_DECLARE_SCALAR_TYPETRAIT_BODY(TYPE, FLAGS)  \
  template <> struct DataTypeSelector<TYPE##Type>   { typedef TYPE Type; };                      \
  template <> struct TypeTraits<TYPE >  {                                                            \
  typedef TYPE ComponentType;                                                                        \
  typedef double IntermediateType;                                                                   \
  enum {                                                                                             \
  dataType              = TYPE##Type,                                                                \
  isBuiltInFloatType    = (((FLAGS) & ML_FLOAT_TYPE) != 0),                                          \
  isBuiltInIntegerType  = (((FLAGS) & ML_INTEGER_TYPE) != 0),                                        \
  isScalarType          = (((FLAGS) & (ML_INTEGER_TYPE | ML_FLOAT_TYPE)) != 0),                      \
  isStandardType        = isScalarType,                                                              \
  isBuiltInSignedType   = (((FLAGS) & ML_SIGNED_TYPE) != 0),                                         \
  is8BitInteger         = ((((FLAGS) & ML_INTEGER_TYPE) != 0) && (sizeof(TYPE)==sizeof(MLuint8))  ), \
  is16BitInteger        = ((((FLAGS) & ML_INTEGER_TYPE) != 0) && (sizeof(TYPE)==sizeof(MLuint16)) ), \
  is32BitInteger        = ((((FLAGS) & ML_INTEGER_TYPE) != 0) && (sizeof(TYPE)==sizeof(MLuint32)) ), \
  is64BitInteger        = ((((FLAGS) & ML_INTEGER_TYPE) != 0) && (sizeof(TYPE)==sizeof(MLuint64)) ), \
  is8_16_32BitInteger   = ((((FLAGS) & ML_INTEGER_TYPE) != 0) &&                                     \
  ((sizeof(TYPE)==sizeof(MLuint8))  ||                                                               \
  (sizeof(TYPE)==sizeof(MLuint16)) ||                                                                \
  (sizeof(TYPE)==sizeof(MLuint32)))),                                                                \
  isUnknown             = false                                                                      \
  };                                                                                                 \
                                                                                                     \
  static inline bool matches(MLDataType dt) { return dt == dataType; }                               \
  static inline MLDataType getDataType() { return dataType; }                                        \
  };

#define ML_DECLARE_SCALAR_TYPETRAIT(TYPE, FLAGS)  \
  _ML_DECLARE_SCALAR_TYPETRAIT_BODY(TYPE, FLAGS)

#define _ML_DECLARE_EXTENDED_TYPETRAIT_BODY(TYPE, TYPE_ID, COMPONENT_TYPE)  \
  template <> struct DataTypeSelector<TYPE_ID>   { typedef TYPE Type; }; \
  template <> struct TypeTraits<TYPE >  {                                    \
  typedef COMPONENT_TYPE ComponentType;                                      \
  typedef TYPE IntermediateType;                                             \
  enum {                           \
  dataType              = TYPE_ID, \
  isBuiltInFloatType    = false,   \
  isBuiltInIntegerType  = false,   \
  isScalarType          = false,   \
  isStandardType        = false,   \
  isBuiltInSignedType   = false,   \
  is8BitInteger         = false,   \
  is16BitInteger        = false,   \
  is32BitInteger        = false,   \
  is64BitInteger        = false,   \
  is8_16_32BitInteger   = false,   \
  isUnknown             = false    \
  };                               \
                                   \
  static inline bool matches(MLDataType dt) { return dt == dataType; }      \
  static inline MLDataType getDataType() { return dataType; }               \
  };

#define ML_DECLARE_EXTENDED_TYPETRAIT(TYPE, TYPE_ID, COMPONENT_TYPE)  \
  _ML_DECLARE_EXTENDED_TYPETRAIT_BODY(TYPE, TYPE_ID, COMPONENT_TYPE)

ML_DECLARE_SCALAR_TYPETRAIT(MLuint8 , ML_INTEGER_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLint8  , ML_INTEGER_TYPE | ML_SIGNED_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLuint16, ML_INTEGER_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLint16 , ML_INTEGER_TYPE | ML_SIGNED_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLuint32, ML_INTEGER_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLint32 , ML_INTEGER_TYPE | ML_SIGNED_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLuint64, ML_INTEGER_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLint64 , ML_INTEGER_TYPE | ML_SIGNED_TYPE)

ML_DECLARE_SCALAR_TYPETRAIT(MLfloat  , ML_FLOAT_TYPE | ML_SIGNED_TYPE)
ML_DECLARE_SCALAR_TYPETRAIT(MLdouble , ML_FLOAT_TYPE | ML_SIGNED_TYPE)

#define ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(TEMPLATE_TYPE, BASE_TYPE, TYPE_ID) \
  ML_DECLARE_EXTENDED_TYPETRAIT(TEMPLATE_TYPE<BASE_TYPE>, TYPE_ID, BASE_TYPE)

ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(std::complex, MLfloat,  MLComplexfType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(std::complex, MLdouble, MLComplexdType)

template <typename DT> class TQuaternion;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(TQuaternion, MLfloat,   MLQuaternionfType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(TQuaternion, MLdouble,  MLQuaterniondType)


template <class DT> class Tvec2;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec2, MLfloat ,  MLVector2fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec2, MLdouble,  MLVector2dType)

template <class DT> class Tvec3;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec3, MLfloat ,  MLVector3fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec3, MLdouble,  MLVector3dType)

template <class DT> class Tvec4;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec4, MLfloat ,  MLVector4fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec4, MLdouble,  MLVector4dType)

template <class DT> class Tvec5;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec5, MLfloat ,  MLVector5fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec5, MLdouble,  MLVector5dType)

template <class DT> class Tvec6;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec6, MLfloat ,  MLVector6fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec6, MLdouble,  MLVector6dType)

template <class DT> class Tvec7;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec7, MLfloat ,  MLVector7fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec7, MLdouble,  MLVector7dType)

template <class DT> class Tvec8;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec8, MLfloat ,  MLVector8fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec8, MLdouble,  MLVector8dType)

template <class DT> class Tvec9;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec9, MLfloat ,  MLVector9fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec9, MLdouble,  MLVector9dType)

template <class DT> class Tvec10;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec10, MLfloat , MLVector10fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec10, MLdouble, MLVector10dType)

template <class DT> class Tvec16;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec16, MLfloat , MLVector16fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec16, MLdouble, MLVector16dType)

template <class DT> class Tvec32;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec32, MLfloat , MLVector32fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec32, MLdouble, MLVector32dType)

template <class DT> class Tvec64;
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec64, MLfloat , MLVector64fType)
ML_DECLARE_FLOAT_VECTOR_TYPETRAIT(Tvec64, MLdouble, MLVector64dType)

#undef ML_DECLARE_FLOAT_VECTOR_TYPETRAIT


#define ML_DECLARE_MATRIX_TYPETRAIT(TEMPLATE_TYPE, BASE_TYPE, TYPE_ID) \
  ML_DECLARE_EXTENDED_TYPETRAIT(TEMPLATE_TYPE<BASE_TYPE>, TYPE_ID, BASE_TYPE)

template <class DT> class Tmat2;
ML_DECLARE_MATRIX_TYPETRAIT(Tmat2, MLfloat ,  MLMatrix2fType)
ML_DECLARE_MATRIX_TYPETRAIT(Tmat2, MLdouble,  MLMatrix2dType)

template <class DT> class Tmat3;
ML_DECLARE_MATRIX_TYPETRAIT(Tmat3, MLfloat ,  MLMatrix3fType)
ML_DECLARE_MATRIX_TYPETRAIT(Tmat3, MLdouble,  MLMatrix3dType)

template <class DT> class Tmat4;
ML_DECLARE_MATRIX_TYPETRAIT(Tmat4, MLfloat ,  MLMatrix4fType)
ML_DECLARE_MATRIX_TYPETRAIT(Tmat4, MLdouble,  MLMatrix4dType)

template <class DT> class Tmat5;
ML_DECLARE_MATRIX_TYPETRAIT(Tmat5, MLfloat ,  MLMatrix5fType)
ML_DECLARE_MATRIX_TYPETRAIT(Tmat5, MLdouble,  MLMatrix5dType)

template <class DT> class Tmat6;
ML_DECLARE_MATRIX_TYPETRAIT(Tmat6, MLfloat ,  MLMatrix6fType)
ML_DECLARE_MATRIX_TYPETRAIT(Tmat6, MLdouble,  MLMatrix6dType)

#undef ML_DECLARE_MATRIX_TYPETRAIT


template <typename CompIntType, int NumDim> class TVectorNDBase;

#define INT_VECTOR_EXPANDER(BASE_TYPE, DIM_NUM) TVectorNDBase<BASE_TYPE, DIM_NUM>

#define ML_DECLARE_INT_VECTOR_TYPETRAIT(BASE_TYPE, DIM_NUM, TYPE_ID) \
  _ML_DECLARE_EXTENDED_TYPETRAIT_BODY(INT_VECTOR_EXPANDER(BASE_TYPE, DIM_NUM), TYPE_ID, BASE_TYPE)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  2,  MLVector2i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  2,  MLVector2i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  2,  MLVector2i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  2,  MLVector2i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  3,  MLVector3i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  3,  MLVector3i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  3,  MLVector3i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  3,  MLVector3i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  4,  MLVector4i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  4,  MLVector4i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  4,  MLVector4i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  4,  MLVector4i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  5,  MLVector5i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  5,  MLVector5i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  5,  MLVector5i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  5,  MLVector5i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  6,  MLVector6i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  6,  MLVector6i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  6,  MLVector6i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  6,  MLVector6i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  7,  MLVector7i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  7,  MLVector7i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  7,  MLVector7i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  7,  MLVector7i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  8,  MLVector8i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  8,  MLVector8i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  8,  MLVector8i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  8,  MLVector8i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 ,  9,  MLVector9i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16,  9,  MLVector9i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32,  9,  MLVector9i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64,  9,  MLVector9i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 , 10,  MLVector10i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16, 10,  MLVector10i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32, 10,  MLVector10i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64, 10,  MLVector10i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 , 16,  MLVector16i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16, 16,  MLVector16i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32, 16,  MLVector16i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64, 16,  MLVector16i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 , 32,  MLVector32i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16, 32,  MLVector32i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32, 32,  MLVector32i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64, 32,  MLVector32i64Type)

ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint8 , 64,  MLVector64i8Type )
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint16, 64,  MLVector64i16Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint32, 64,  MLVector64i32Type)
ML_DECLARE_INT_VECTOR_TYPETRAIT(MLint64, 64,  MLVector64i64Type)

#undef ML_DECLARE_INT_VECTOR_TYPETRAIT
#undef INT_VECTOR_EXPANDER

ML_END_NAMESPACE


namespace OverloadSelector {

template<bool b> struct SwitchType {};
typedef SwitchType<true>  OnTrue;
typedef SwitchType<false> OnFalse;

template<typename T>
SwitchType<ML_NAMESPACE::TypeTraits<T>::isStandardType> isScalarType() {
  return SwitchType<ML_NAMESPACE::TypeTraits<T>::isStandardType>();
}

template<typename T>
SwitchType<ML_NAMESPACE::TypeTraits<T>::isBuiltInIntegerType> isBuiltInIntegerType() {
  return SwitchType<ML_NAMESPACE::TypeTraits<T>::isBuiltInIntegerType>();
}

};

template<typename T>
inline typename ML_NAMESPACE::TypeTraits<T>::ComponentType ml_component_cast(double v)
{
  return static_cast<typename ML_NAMESPACE::TypeTraits<T>::ComponentType>(v);
}

template<typename T>
inline typename ML_NAMESPACE::TypeTraits<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>::ComponentType
ml_scalar_factor_cast(double v)
{
  return ml_component_cast<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>(v);
}

template<typename T>
inline typename ML_NAMESPACE::TypeTraits<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>::ComponentType
ml_scalar_factor_cast(double v, const T& dummy)
{
  return ml_component_cast<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>(v);
}

template<typename T>
inline T ml_cast_from_scalar(double v)
{
  return static_cast<T>(ml_component_cast<T>(v));
}

template<typename T>
inline typename ML_NAMESPACE::TypeTraits<T>::IntermediateType ml_cast_to_intermediate_type(const T& v)
{
  return static_cast<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>(v);
}

template<typename T, typename S>
inline typename ML_NAMESPACE::TypeTraits<T>::IntermediateType
ml_cast_to_intermediate_type_and_multiply(const T& v, S s)
{
  return static_cast<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>(v) *
    ml_component_cast<typename ML_NAMESPACE::TypeTraits<T>::IntermediateType>(s);
}

// version for built-in integer types, does clamping and rounding
template<typename T>
inline T _ml_cast_from_intermediate_type(const typename ML_NAMESPACE::TypeTraits<T>::IntermediateType& v, OverloadSelector::OnTrue)
{
  // clamping to allowed value range:
  if (v < _ml_numeric_limits<T>::MinValue) {
    return static_cast<T>(_ml_numeric_limits<T>::MinValue);
  } else if (v > _ml_numeric_limits<T>::MaxValue) {
    return static_cast<T>(_ml_numeric_limits<T>::MaxValue);
  } else {
    // rounding to next integer:
    return static_cast<T>(floor(v+0.5));
  }
}

// version for all other types, does nothing
template<typename T>
inline T _ml_cast_from_intermediate_type(const typename ML_NAMESPACE::TypeTraits<T>::IntermediateType& v, OverloadSelector::OnFalse)
{
  return static_cast<T>(v);
}

template<typename T>
inline T ml_cast_from_intermediate_type(const typename ML_NAMESPACE::TypeTraits<T>::IntermediateType& v)
{
  return _ml_cast_from_intermediate_type<T>(v, OverloadSelector::isBuiltInIntegerType<T>());
}

// version for built-in integer types, does rounding
template<typename T>
inline T _ml_cast_from_intermediate_type_without_clamping(const typename ML_NAMESPACE::TypeTraits<T>::IntermediateType& v, OverloadSelector::OnTrue)
{
  return static_cast<T>(floor(v+0.5));
}

// version for all other types, does nothing
template<typename T>
inline T _ml_cast_from_intermediate_type_without_clamping(const typename ML_NAMESPACE::TypeTraits<T>::IntermediateType& v, OverloadSelector::OnFalse)
{
  return static_cast<T>(v);
}

template<typename T>
inline T ml_cast_from_intermediate_type_without_clamping(const typename ML_NAMESPACE::TypeTraits<T>::IntermediateType& v)
{
  return _ml_cast_from_intermediate_type_without_clamping<T>(v, OverloadSelector::isBuiltInIntegerType<T>());
}


#endif // of __mlTypeTraits_H