mlStdTypeInfos.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_STD_TYPE_INFOS_H
#define ML_STD_TYPE_INFOS_H
 
 
// ML-includes
#include "mlErrorMacros.h"
#include "mlErrorOutput.h"
#include "mlInitSystemML.h"
#include "mlTypeDefTraits.h"
#include "mlTypeTraits.h"
 
#include <algorithm>
#include <cmath>
 
ML_START_NAMESPACE
 
const MLint _ML_STD_SLEN=64;
 
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
template <typename VTYP>
class MLEXPORT MLTStdTypeInfos : public MLTypeInfos
{
 
public:
 
  static inline const char *typeName(MLint8   *) { static const char name[]="int8";           return name; }
  static inline const char *typeName(MLuint8  *) { static const char name[]="unsigned int8";  return name; }
  static inline const char *typeName(MLint16  *) { static const char name[]="int16";          return name; }
  static inline const char *typeName(MLuint16 *) { static const char name[]="unsigned int16"; return name; }
  static inline const char *typeName(MLint32  *) { static const char name[]="int32";          return name; }
  static inline const char *typeName(MLuint32 *) { static const char name[]="unsigned int32"; return name; }
  static inline const char *typeName(MLfloat  *) { static const char name[]="float";          return name; }
  static inline const char *typeName(MLdouble *) { static const char name[]="double";         return name; }
  static inline const char *typeName(MLint64  *) { static const char name[]="int64";          return name; }
  static inline const char *typeName(MLuint64 *) { static const char name[]="unsigned int64"; return name; }
 
protected:
  static const VTYP _typeMin;
 
  static const VTYP _typeMax;
 
  static const VTYP _typeDefault;
 
  static const char _typeInfoString[_ML_STD_SLEN];
 
  inline MLDataType _rangeAndPrecisionEquiv(MLint8   ) { return MLint8Type;    }
  inline MLDataType _rangeAndPrecisionEquiv(MLuint8  ) { return MLuint8Type;   }
  inline MLDataType _rangeAndPrecisionEquiv(MLint16  ) { return MLint16Type;   }
  inline MLDataType _rangeAndPrecisionEquiv(MLuint16 ) { return MLuint16Type;  }
  inline MLDataType _rangeAndPrecisionEquiv(MLint32  ) { return MLint32Type;   }
  inline MLDataType _rangeAndPrecisionEquiv(MLuint32 ) { return MLuint32Type;  }
  inline MLDataType _rangeAndPrecisionEquiv(MLfloat  ) { return MLfloatType;   }
  inline MLDataType _rangeAndPrecisionEquiv(MLdouble ) { return MLdoubleType;  }
  inline MLDataType _rangeAndPrecisionEquiv(MLint64  ) { return MLint64Type;   }
  inline MLDataType _rangeAndPrecisionEquiv(MLuint64 ) { return MLuint64Type;  }
 
  static inline       VTYP& value_cast(      MLTypeData* v) { return *(reinterpret_cast<      VTYP*>(v)); }
  static inline const VTYP& value_cast(const MLTypeData* v) { return *(reinterpret_cast<const VTYP*>(v)); }
 
  static inline VTYP castToType(MLdouble v)  { return static_cast<VTYP>(floor(v+0.5)); }
 
  inline void _getGoodCastTos(MLint8, MLuint &num, const char **&typeNames)
  {
    num = 5;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLint16  >::typeName(static_cast<MLint16  *>(nullptr)),
      MLTStdTypeInfos<MLint32  >::typeName(static_cast<MLint32  *>(nullptr)),
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
      MLTStdTypeInfos<MLint64  >::typeName(static_cast<MLint64  *>(nullptr))
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLuint8, MLuint &num, const char **&typeNames)
  {
    num = 8;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLint16  >::typeName(static_cast<MLint16  *>(nullptr)),
      MLTStdTypeInfos<MLuint16 >::typeName(static_cast<MLuint16 *>(nullptr)),
      MLTStdTypeInfos<MLint32  >::typeName(static_cast<MLint32  *>(nullptr)),
      MLTStdTypeInfos<MLuint32 >::typeName(static_cast<MLuint32 *>(nullptr)),
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
      MLTStdTypeInfos<MLint64  >::typeName(static_cast<MLint64  *>(nullptr)),
      MLTStdTypeInfos<MLuint64 >::typeName(static_cast<MLuint64 *>(nullptr))
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLint16, MLuint &num, const char **&typeNames)
  {
    num = 4;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLint32  >::typeName(static_cast<MLint32  *>(nullptr)),
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
      MLTStdTypeInfos<MLint64  >::typeName(static_cast<MLint64  *>(nullptr))
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLuint16, MLuint &num, const char **&typeNames)
  {
    num = 6;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLint32  >::typeName(static_cast<MLint32  *>(nullptr)),
      MLTStdTypeInfos<MLuint32 >::typeName(static_cast<MLuint32 *>(nullptr)),
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
      MLTStdTypeInfos<MLint64  >::typeName(static_cast<MLint64  *>(nullptr)),
      MLTStdTypeInfos<MLuint64 >::typeName(static_cast<MLuint64 *>(nullptr))
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLint32, MLuint &num, const char **&typeNames)
  {
    num = 3;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
      MLTStdTypeInfos<MLint64  >::typeName(static_cast<MLint64  *>(nullptr))
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLuint32, MLuint &num, const char **&typeNames)
  {
    num = 4;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
      MLTStdTypeInfos<MLint64  >::typeName(static_cast<MLint64  *>(nullptr)),
      MLTStdTypeInfos<MLuint64 >::typeName(static_cast<MLuint64 *>(nullptr))
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLfloat, MLuint &num, const char **&typeNames)
  {
    num = 1;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLdouble, MLuint &num, const char **&typeNames)
  {
    num = 0;
    typeNames = nullptr;
  }
 
  inline void _getGoodCastTos(MLint64, MLuint &num, const char **&typeNames)
  {
    num = 2;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
    };
    typeNames = v;
  }
 
  inline void _getGoodCastTos(MLuint64, MLuint &num, const char **&typeNames)
  {
    num = 2;
    static const char *v[] =
    {
      MLTStdTypeInfos<MLfloat  >::typeName(static_cast<MLfloat  *>(nullptr)),
      MLTStdTypeInfos<MLdouble >::typeName(static_cast<MLdouble *>(nullptr)),
    };
    typeNames = v;
  }
 
  static MLTypeInfos *_myInfos;
 
  static MLint32      _numInstances;
 
public:
 
  MLTStdTypeInfos()
  {
    if (_numInstances > 0)
    {
      ML_PRINT_FATAL_ERROR("MLTStdTypeInfos", ML_PROGRAMMING_ERROR, "Too many instances of MLTStdTypeInfos created.");
      ML_HARAKIRI
    }
    _numInstances++;
 
    // Save pointer to the one instance of this class.
    _myInfos     = this;
 
    ML_TYPE_ASSIGN_FUNCTION_POINTERS();
 
    // Determine the type to which this type can be casted without information loss.
    MLuint numLocalGoodCastTos=0;
    const char **goodLocalCastTos=nullptr;
    _getGoodCastTos(static_cast<VTYP>(0), numLocalGoodCastTos, goodLocalCastTos);
 
    VTYP buf=0;
    void *addr[1];
    addr[0] = &buf;
    MLTypeInfosInit(this,
                    sizeof(VTYP),
                    typeName(static_cast<VTYP*>(nullptr)),
                    _typeMin,
                    _typeMax,
                    reinterpret_cast<const MLTypeData*>(&_typeMin),
                    reinterpret_cast<const MLTypeData*>(&_typeMax),
                    reinterpret_cast<const MLTypeData*>(&_typeDefault),
                    _typeInfoString,
                    true,
                    MLScalarTypeGroup,
                    _rangeAndPrecisionEquiv(static_cast<VTYP>(0)),
                    addr,
                    numLocalGoodCastTos,
                    goodLocalCastTos
                    );
  }
 
 
  //-------------------------------------------------------------------------------
  // Methods to be overloaded:
  //-------------------------------------------------------------------------------
 
 
  static char       *MLTYPE_getStringValue        (const MLTypeData *p)                                       { return MLTypeComponentsToString(_myInfos, p); }
  static void        MLTYPE_setStringValue        (const char *s, MLTypeData *r)
  {
    if (auto result = MLTypeComponentsFromString(_myInfos, s, reinterpret_cast<const MLTypeData*>(&_typeDefault), r); result != 1)
    {
      logTypeComponentsFromStringError(__FUNCTION__);
    }
  }
 
  static void        MLTYPE_setToMinimum          (MLTypeData *p)                                             { value_cast(p) = _typeMin; }
  static void        MLTYPE_setToMaximum          (MLTypeData *p)                                             { value_cast(p) = _typeMax; }
  static void        MLTYPE_setToDefault          (MLTypeData *p)                                             { value_cast(p) = _typeDefault; }
  static MLdouble    MLTYPE_getComponent          (const MLTypeData *p, size_t /*n*/)                         { return static_cast<MLdouble>(value_cast(p)); }
  static void        MLTYPE_setComponent          (MLTypeData *p, size_t /*n*/, MLdouble v)                   { value_cast(p) = static_cast<VTYP>(v); }
  static void        MLTYPE_copy                  (const MLTypeData *source, MLTypeData *dest)                { value_cast(dest) = value_cast(source); }
  static void        MLTYPE_arrayCopy             (const MLTypeData *source, MLTypeData *dest, size_t size)   { memcpy(dest, source, sizeof(VTYP)*size); }
  static void        MLTYPE_arrayCopyWithStrides  (const MLTypeData *source, MLssize_t sourceStride, MLTypeData *dest, MLssize_t destStride, size_t size)
  {
    for (size_t i=0;i<size;i++)
    {
      value_cast(dest) = value_cast(source);
      source += sizeof(VTYP)*sourceStride;
      dest   += sizeof(VTYP)*destStride;
    }
  }
 
  static void        MLTYPE_arrayFill             (const MLTypeData *fillValue, MLTypeData *dest, size_t n)
  {
    const VTYP value = value_cast(fillValue);
    VTYP* arrayPtr = &value_cast(dest);
 
    // Use memset if 8bit integer is used or if fillValue is 0
    if (TypeTraits<VTYP>::is8BitInteger || value == 0) {
      if (arrayPtr){ // Avoid complaining memory checkers in memset if arrayPtr and n is NULL/0.
        memset(arrayPtr, value, n* sizeof(VTYP) );
      }
    } else {
      for (size_t i = 0; i < n; i++) {
        *arrayPtr++ = value;
      }
    }
  }
 
  static bool        MLTYPE_castToBool            (const MLTypeData *p)                                       { return MLValuesDifferWOM(value_cast(p), static_cast<VTYP>(0)); }
  static MLint       MLTYPE_castToInt             (const MLTypeData *p)                                       { return static_cast<MLint>(value_cast(p)); }
  static MLdouble    MLTYPE_castToDouble          (const MLTypeData *p)                                       { return static_cast<MLdouble>(value_cast(p)); }
  static void        MLTYPE_castToOtherType(const MLTypeData *myData, const MLTypeInfos *otherInfos, MLTypeData *otherData) { MLTypeCastToOtherType(_myInfos, myData,  otherInfos, otherData); }
 
  static void        MLTYPE_castFromInt           (MLint p, MLTypeData *q)                                  { value_cast(q) = static_cast<VTYP>(p); }
  static void        MLTYPE_castFromDouble        (MLdouble p, MLTypeData *q)                                 { value_cast(q) = static_cast<VTYP>(p); }
  static void        MLTYPE_castFromOtherType     (const MLTypeInfos *otherInfos, const MLTypeData *otherData,
                                                   MLTypeData *myData)                                        { MLTypeCastToOtherType(otherInfos,otherData, _myInfos, myData);   }
 
  static bool        MLTYPE_isEqualToType         (const MLTypeData *p, const MLTypeData *q)                  { return MLValuesAreEqualWOM(value_cast(p), value_cast(q)); }
  static bool        MLTYPE_isEqualToTypeWithEpsilon(const MLTypeData *p, const MLTypeData *q, MLdouble eps)  { return MLAbs(value_cast(p)-value_cast(q)) < eps; }
 
  static void        MLTYPE_negate                (const MLTypeData *p, MLTypeData *q)                        { value_cast(q) = -value_cast(p); }
 
  static void        MLTYPE_normalize             (const MLTypeData * /*p*/, MLTypeData *q)                   { value_cast(q) = 1; }
 
  static void        MLTYPE_arrayRescale          (const MLTypeData* source, MLdouble factor, const MLTypeData* offset, MLTypeData* dest, size_t size) {
    const VTYP* srcPtr = &value_cast(source);
    VTYP* destPtr      = &value_cast(dest);
    const VTYP offsetValue = value_cast(offset);
    for (size_t i = 0; i<size; i++) {
      *destPtr++ = castToType((*srcPtr++) * factor + offsetValue);
    }
  }
 
  static bool        MLTYPE_arrayEqualsValue     (const MLTypeData* value, const MLTypeData* buffer, size_t size) {
    const VTYP constValue = value_cast(value);
    const VTYP* arrayPtr = &value_cast(buffer);
    for (size_t i=0; i<size; i++) {
      if (*arrayPtr++ != constValue) { return false; }
    }
    return true;
  }
 
  static void        MLTYPE_arrayGetMinMax       (const MLTypeData* p, size_t s, MLdouble& min, MLdouble& max) {
 
    const auto *begin = reinterpret_cast<const VTYP *>(p);
    auto min_max = std::minmax_element(begin, begin + s);
    min = static_cast<double>(*min_max.first);
    max = static_cast<double>(*min_max.second);
  }
 
 
  static void        MLTYPE_interpolate           (const MLTypeData* p, const MLTypeData* q, MLdouble r, MLTypeData* t) {
    value_cast(t) = castToType(value_cast(p) * (1.0-r) + value_cast(q) * r);
  }
 
  static void        MLTYPE_multWithInt           (const MLTypeData *p, MLint q,             MLTypeData *r)   { value_cast(r) = static_cast<VTYP>(value_cast(p) * q);   }
  static void        MLTYPE_multWithDouble        (const MLTypeData *p, MLdouble q,          MLTypeData *r)   { value_cast(r) = static_cast<VTYP>(value_cast(p) * q);   }
  static void        MLTYPE_multWithType          (const MLTypeData *p, const MLTypeData *q, MLTypeData *r)   { value_cast(r) = value_cast(p)*value_cast(q); }
  static void        MLTYPE_multWithOtherType     (const MLTypeInfos *otherInfos, const MLTypeData *otherData,
                                                   const MLTypeData *myData, MLTypeData *r)                   { MLTypeMultWithOtherType(_myInfos, myData, otherInfos, otherData, r); }
 
  static void        MLTYPE_plusInt          (const MLTypeData *p, MLint q,             MLTypeData *r)   { value_cast(r) = value_cast(p) + q;                     }
  static void        MLTYPE_plusDouble       (const MLTypeData *p, MLdouble q,          MLTypeData *r)   { value_cast(r) = static_cast<VTYP>(value_cast(p) + q);  }
  static void        MLTYPE_plusType         (const MLTypeData *p, const MLTypeData *q, MLTypeData *r)   { value_cast(r) = value_cast(p) + value_cast(q);         }
 
};
 
template<> inline MLfloat   MLTStdTypeInfos<MLfloat  >::castToType(MLdouble v) { return static_cast<MLfloat  >(v); }
template<> inline MLdouble  MLTStdTypeInfos<MLdouble >::castToType(MLdouble v) { return v;                         }
 
 
// For unsigned types implement specialized negations to avoid warning due to negations of unsigned types. We just copy instead of negating.
template<> inline void MLTStdTypeInfos<MLuint8  >::MLTYPE_negate      (const MLTypeData *p, MLTypeData *q)                     { value_cast(q) = value_cast(p);   }
template<> inline void MLTStdTypeInfos<MLuint16 >::MLTYPE_negate      (const MLTypeData *p, MLTypeData *q)                     { value_cast(q) = value_cast(p);   }
template<> inline void MLTStdTypeInfos<MLuint32 >::MLTYPE_negate      (const MLTypeData *p, MLTypeData *q)                     { value_cast(q) = value_cast(p);   }
template<> inline void MLTStdTypeInfos<MLuint64 >::MLTYPE_negate      (const MLTypeData *p, MLTypeData *q)                     { value_cast(q) = value_cast(p);   }
 
 
// Member initializations for unspecialized class members.
template <typename VTYP> const VTYP   MLTStdTypeInfos<VTYP>::_typeDefault                  = VTYP(0);
template <typename VTYP> MLTypeInfos* MLTStdTypeInfos<VTYP>::_myInfos                      = nullptr;
template <typename VTYP> MLint32      MLTStdTypeInfos<VTYP>::_numInstances                 = 0;
 
ML_END_NAMESPACE
 
 
#endif //of __mlStdTypeInfos_H